Class LookaheadStream<T>

java.lang.Object
org.antlr.runtime.misc.FastQueue<T>
org.antlr.runtime.misc.LookaheadStream<T>
Direct Known Subclasses:
CommonTreeNodeStream, UnbufferedTokenStream
public abstract class LookaheadStream<T> extends FastQueue<T>
A lookahead queue that knows how to mark/release locations in the buffer for backtracking purposes. Any markers force the FastQueue superclass to keep all elements until no more markers; then can reset to avoid growing a huge buffer.

  • Field Details

    • UNINITIALIZED_EOF_ELEMENT_INDEX

      public static final int UNINITIALIZED_EOF_ELEMENT_INDEX
      See Also:

    • currentElementIndex

      protected int currentElementIndex
      Absolute token index. It's the index of the symbol about to be read via LT(1). Goes from 0 to numtokens.

    • prevElement

      protected T prevElement
      This is the LT(-1) element for the first element in FastQueue.data.

    • eof

      public T eof
      Track object returned by nextElement upon end of stream; Return it later when they ask for LT passed end of input.

    • lastMarker

      protected int lastMarker
      Track the last mark() call result value for use in rewind().

    • markDepth

      protected int markDepth
      tracks how deep mark() calls are nested

  • Constructor Details

    • LookaheadStream

      public LookaheadStream()

  • Method Details

    • reset

      public void reset()
      Overrides:
      reset in class FastQueue<T>

    • nextElement

      public abstract T nextElement()
      Implement nextElement to supply a stream of elements to this lookahead buffer. Return EOF upon end of the stream we're pulling from.
      See Also:

    • isEOF

      public abstract boolean isEOF(T o)

    • remove

      public T remove()
      Get and remove first element in queue; override FastQueue.remove(); it's the same, just checks for backtracking.
      Overrides:
      remove in class FastQueue<T>

    • consume

      public void consume()
      Make sure we have at least one element to remove, even if EOF

    • syncAhead

      protected void syncAhead(int need)
      Make sure we have 'need' elements from current position p. Last valid p index is data.size()-1. p+need-1 is the data index 'need' elements ahead. If we need 1 element, (p+1-1)==p must be < data.size().

    • fill

      public void fill(int n)
      add n elements to buffer

    • size

      public int size()
      Size of entire stream is unknown; we only know buffer size from FastQueue.
      Overrides:
      size in class FastQueue<T>

    • LT

      public T LT(int k)

    • index

      public int index()

    • mark

      public int mark()

    • release

      public void release(int marker)

    • rewind

      public void rewind(int marker)

    • rewind

      public void rewind()

    • seek

      public void seek(int index)
      Seek to a 0-indexed absolute token index. Normally used to seek backwards in the buffer. Does not force loading of nodes.

      To preserve backward compatibility, this method allows seeking past the end of the currently buffered data. In this case, the input pointer will be moved but the data will only actually be loaded upon the next call to consume() or LT(int) for k>0.

      Throws:
      IllegalArgumentException - if index is less than 0
      UnsupportedOperationException - if index lies before the beginning of the moving window buffer (index < currentElementIndex - p).

    • LB

      protected T LB(int k)