272 lines
8.7 KiB
C#
272 lines
8.7 KiB
C#
/*
|
|
* [The "BSD licence"]
|
|
* Copyright (c) 2005-2008 Terence Parr
|
|
* All rights reserved.
|
|
*
|
|
* Conversion to C#:
|
|
* Copyright (c) 2008-2009 Sam Harwell, Pixel Mine, Inc.
|
|
* 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.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
namespace Antlr.Runtime.Misc
|
|
{
|
|
using ArgumentException = System.ArgumentException;
|
|
using Debug = System.Diagnostics.Debug;
|
|
using InvalidOperationException = System.InvalidOperationException;
|
|
using NotSupportedException = System.NotSupportedException;
|
|
using ArgumentOutOfRangeException = System.ArgumentOutOfRangeException;
|
|
|
|
/** <summary>
|
|
* A lookahead queue that knows how to mark/release locations in the buffer for
|
|
* backtracking purposes. Any markers force the {@link FastQueue} superclass to
|
|
* keep all elements until no more markers; then can reset to avoid growing a
|
|
* huge buffer.
|
|
* </summary>
|
|
*/
|
|
public abstract class LookaheadStream<T>
|
|
: FastQueue<T>
|
|
where T : class
|
|
{
|
|
/** Absolute token index. It's the index of the symbol about to be
|
|
* read via {@code LT(1)}. Goes from 0 to numtokens.
|
|
*/
|
|
private int _currentElementIndex = 0;
|
|
|
|
/**
|
|
* This is the {@code LT(-1)} element for the first element in {@link #data}.
|
|
*/
|
|
private T _previousElement;
|
|
|
|
/** Track object returned by nextElement upon end of stream;
|
|
* Return it later when they ask for LT passed end of input.
|
|
*/
|
|
T _eof = null;
|
|
|
|
/** <summary>Track the last mark() call result value for use in rewind().</summary> */
|
|
int _lastMarker;
|
|
|
|
/** <summary>tracks how deep mark() calls are nested</summary> */
|
|
int _markDepth;
|
|
|
|
public T EndOfFile
|
|
{
|
|
get
|
|
{
|
|
return _eof;
|
|
}
|
|
protected set
|
|
{
|
|
_eof = value;
|
|
}
|
|
}
|
|
|
|
public T PreviousElement
|
|
{
|
|
get
|
|
{
|
|
return _previousElement;
|
|
}
|
|
}
|
|
|
|
public virtual void Reset()
|
|
{
|
|
Clear();
|
|
_currentElementIndex = 0;
|
|
_p = 0;
|
|
_previousElement = null;
|
|
}
|
|
|
|
/** <summary>
|
|
* Implement nextElement to supply a stream of elements to this
|
|
* lookahead buffer. Return EOF upon end of the stream we're pulling from.
|
|
* </summary>
|
|
*/
|
|
public abstract T NextElement();
|
|
|
|
public abstract bool IsEndOfFile(T o);
|
|
|
|
/** <summary>
|
|
* Get and remove first element in queue; override
|
|
* {@link FastQueue#remove()}; it's the same, just checks for backtracking.
|
|
* </summary> */
|
|
public override T Dequeue()
|
|
{
|
|
T o = this[0];
|
|
_p++;
|
|
// have we hit end of buffer and not backtracking?
|
|
if ( _p == _data.Count && _markDepth == 0 )
|
|
{
|
|
_previousElement = o;
|
|
// if so, it's an opportunity to start filling at index 0 again
|
|
Clear(); // size goes to 0, but retains memory
|
|
}
|
|
return o;
|
|
}
|
|
|
|
/** <summary>Make sure we have at least one element to remove, even if EOF</summary> */
|
|
public virtual void Consume()
|
|
{
|
|
SyncAhead(1);
|
|
Dequeue();
|
|
_currentElementIndex++;
|
|
}
|
|
|
|
/** <summary>
|
|
* 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().
|
|
* </summary>
|
|
*/
|
|
protected virtual void SyncAhead( int need )
|
|
{
|
|
int n = ( _p + need - 1 ) - _data.Count + 1; // how many more elements we need?
|
|
if ( n > 0 )
|
|
Fill( n ); // out of elements?
|
|
}
|
|
|
|
/** <summary>add n elements to buffer</summary> */
|
|
public virtual void Fill( int n )
|
|
{
|
|
for ( int i = 0; i < n; i++ )
|
|
{
|
|
T o = NextElement();
|
|
if ( IsEndOfFile(o) )
|
|
_eof = o;
|
|
|
|
_data.Add( o );
|
|
}
|
|
}
|
|
|
|
/** <summary>Size of entire stream is unknown; we only know buffer size from FastQueue</summary> */
|
|
public override int Count
|
|
{
|
|
get
|
|
{
|
|
throw new System.NotSupportedException( "streams are of unknown size" );
|
|
}
|
|
}
|
|
|
|
public virtual T LT( int k )
|
|
{
|
|
if ( k == 0 )
|
|
{
|
|
return null;
|
|
}
|
|
if ( k < 0 )
|
|
{
|
|
return LB(-k);
|
|
}
|
|
|
|
SyncAhead( k );
|
|
if ((_p + k - 1) > _data.Count)
|
|
return _eof;
|
|
|
|
return this[k - 1];
|
|
}
|
|
|
|
public virtual int Index
|
|
{
|
|
get
|
|
{
|
|
return _currentElementIndex;
|
|
}
|
|
}
|
|
|
|
public virtual int Mark()
|
|
{
|
|
_markDepth++;
|
|
_lastMarker = _p; // track where we are in buffer, not absolute token index
|
|
return _lastMarker;
|
|
}
|
|
|
|
public virtual void Release( int marker )
|
|
{
|
|
if (_markDepth == 0)
|
|
throw new InvalidOperationException();
|
|
|
|
_markDepth--;
|
|
}
|
|
|
|
public virtual void Rewind( int marker )
|
|
{
|
|
_markDepth--;
|
|
int delta = _p - marker;
|
|
_currentElementIndex -= delta;
|
|
_p = marker;
|
|
}
|
|
|
|
public virtual void Rewind()
|
|
{
|
|
// rewind but do not release marker
|
|
int delta = _p - _lastMarker;
|
|
_currentElementIndex -= delta;
|
|
_p = _lastMarker;
|
|
}
|
|
|
|
/** <summary>
|
|
* Seek to a 0-indexed absolute token index. Normally used to seek backwards
|
|
* in the buffer. Does not force loading of nodes.
|
|
* </summary>
|
|
* <remarks>
|
|
* 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
|
|
* {@link #consume} or {@link #LT} for {@code k>0}.
|
|
* </remarks>
|
|
*/
|
|
public virtual void Seek( int index )
|
|
{
|
|
if (index < 0)
|
|
throw new ArgumentOutOfRangeException("index");
|
|
|
|
int delta = _currentElementIndex - index;
|
|
if (_p - delta < 0)
|
|
throw new NotSupportedException("can't seek before the beginning of this stream's buffer");
|
|
|
|
_p -= delta;
|
|
_currentElementIndex = index;
|
|
}
|
|
|
|
protected virtual T LB(int k)
|
|
{
|
|
Debug.Assert(k > 0);
|
|
|
|
int index = _p - k;
|
|
if (index == -1)
|
|
return _previousElement;
|
|
|
|
// if k>0 then we know index < data.size(). avoid the double-check for
|
|
// performance.
|
|
if (index >= 0 /*&& index < data.size()*/)
|
|
return _data[index];
|
|
|
|
if (index < -1)
|
|
throw new NotSupportedException("can't look more than one token before the beginning of this stream's buffer");
|
|
|
|
throw new NotSupportedException("can't look past the end of this stream's buffer using LB(int)");
|
|
}
|
|
}
|
|
}
|