package antlr;

/* ANTLR Translator Generator
 * Project led by Terence Parr at http://www.cs.usfca.edu
 * Software rights: http://www.antlr.org/license.html
 *
 * $Id: //depot/code/org.antlr/release/antlr-2.7.7/antlr/InputBuffer.java#2 $
 */

// SAS: Added this class to genericise the input buffers for scanners
//      This allows a scanner to use a binary (FileInputStream) or
//      text (FileReader) stream of data; the generated scanner
//      subclass will define the input stream
//      There are two subclasses to this: CharBuffer and ByteBuffer

import java.io.IOException;

/**A Stream of characters fed to the lexer from a InputStream that can
 * be rewound via mark()/rewind() methods.
 * <p>
 * A dynamic array is used to buffer up all the input characters.  Normally,
 * "k" characters are stored in the buffer.  More characters may be stored during
 * guess mode (testing syntactic predicate), or when LT(i>k) is referenced.
 * Consumption of characters is deferred.  In other words, reading the next
 * character is not done by conume(), but deferred until needed by LA or LT.
 * <p>
 *
 * @see antlr.CharQueue
 */
public abstract class InputBuffer {
    // Number of active markers
    protected int nMarkers = 0;

    // Additional offset used when markers are active
    protected int markerOffset = 0;

    // Number of calls to consume() since last LA() or LT() call
    protected int numToConsume = 0;

    // Circular queue
    protected CharQueue queue;

    /** Create an input buffer */
    public InputBuffer() {
        queue = new CharQueue(1);
    }

    /** This method updates the state of the input buffer so that
     *  the text matched since the most recent mark() is no longer
     *  held by the buffer.  So, you either do a mark/rewind for
     *  failed predicate or mark/commit to keep on parsing without
     *  rewinding the input.
     */
    public void commit() {
        nMarkers--;
    }

    /** Mark another character for deferred consumption */
    public void consume() {
        numToConsume++;
    }

    /** Ensure that the input buffer is sufficiently full */
    public abstract void fill(int amount) throws CharStreamException;

    public String getLAChars() {
        StringBuffer la = new StringBuffer();
        for (int i = markerOffset; i < queue.nbrEntries; i++)
            la.append(queue.elementAt(i));
        return la.toString();
    }

    public String getMarkedChars() {
        StringBuffer marked = new StringBuffer();
        for (int i = 0; i < markerOffset; i++)
            marked.append(queue.elementAt(i));
        return marked.toString();
    }

    public boolean isMarked() {
        return (nMarkers != 0);
    }

    /** Get a lookahead character */
    public char LA(int i) throws CharStreamException {
        fill(i);
        return queue.elementAt(markerOffset + i - 1);
    }

    /**Return an integer marker that can be used to rewind the buffer to
     * its current state.
     */
    public int mark() {
        syncConsume();
        nMarkers++;
        return markerOffset;
    }

    /**Rewind the character buffer to a marker.
     * @param mark Marker returned previously from mark()
     */
    public void rewind(int mark) {
        syncConsume();
        markerOffset = mark;
        nMarkers--;
    }

    /** Reset the input buffer
     */
    public void reset() {
        nMarkers = 0;
        markerOffset = 0;
        numToConsume = 0;
        queue.reset();
    }

    /** Sync up deferred consumption */
    protected void syncConsume() {
        while (numToConsume > 0) {
            if (nMarkers > 0) {
                // guess mode -- leave leading characters and bump offset.
                markerOffset++;
            }
            else {
                // normal mode -- remove first character
                queue.removeFirst();
            }
            numToConsume--;
        }
    }
}
