Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   [The "BSD license"]
   Copyright (c) 2005-2009 Terence Parr
   All rights reserved.
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
   1. Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
  2. Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
  3. The name of the author may not be used to endorse or promote products
      derived from this software without specific prior written permission.
 package org.antlr.runtime.misc;
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 tokens until no more markers; then can reset to avoid growing a huge buffer.
 public abstract class LookaheadStream<T> extends FastQueue<T> {
     public static final int UNINITIALIZED_EOF_ELEMENT_INDEX = .;

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

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

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

tracks how deep mark() calls are nested
     protected int markDepth = 0;
     public void reset() {
          = 0;
          = 0;
Implement nextElement to supply a stream of elements to this lookahead buffer. Return eof upon end of the stream we're pulling from.
     public abstract T nextElement();
     public abstract boolean isEOF(T o);

Get and remove first element in queue; override FastQueue.remove(); it's the same, just checks for backtracking.
     public T remove() {
         T o = elementAt(0);
         // have we hit end of buffer and not backtracking?
         if (  == .size() && ==0 ) {
             // if so, it's an opportunity to start filling at index 0 again
             clear(); // size goes to 0, but retains memory
         return o;

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

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().
     protected void syncAhead(int need) {
        int n = (+need-1) - .size() + 1; // how many more elements we need?
        if ( n > 0 ) fill(n);                 // out of elements?

add n elements to buffer
    public void fill(int n) {
        for (int i=1; i<=ni++) {
            T o = nextElement();
            if ( isEOF(o) )  = o;

Size of entire stream is unknown; we only know buffer size from FastQueue
    public int size() { throw new UnsupportedOperationException("streams are of unknown size"); }
    public T LT(int k) {
		if ( k==0 ) {
			return null;
		if ( k<0 ) return LB(-k);
        if ( (+k-1) > .size() ) return ;
        return elementAt(k-1);
    public int index() { return ; }
	public int mark() {
         = // track where we are in buffer not absolute token index
        return ;
	public void release(int marker) {
		// no resources to release
	public void rewind(int marker) {
        seek(marker); // assume marker is top
        // release(marker); // waste of call; it does nothing in this class
	public void rewind() {
        seek(); // rewind but do not release marker

Seek to a 0-indexed position within data buffer. Can't handle case where you seek beyond end of existing buffer. Normally used to seek backwards in the buffer. Does not force loading of nodes. Doesn't see to absolute position in input stream since this stream is unbuffered. Seeks only into our moving window of elements.
    public void seek(int index) {  = index; }
    protected T LB(int k) {
        if ( k==1 ) return ;
        throw new NoSuchElementException("can't look backwards more than one token in this stream");
New to GrepCode? Check out our FAQ X