/*
* [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 InvalidOperationException = System.InvalidOperationException;
/** <summary>
* 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.
* </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 LT(1). Goes from 0 to numtokens.
*/
private int _currentElementIndex = 0;
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 override void Clear()
{
base.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 FastQueue.remove()</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 )
{
// 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);
_previousElement = 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 )
{
Seek( marker );
Release( marker );
}
public virtual void Rewind()
{
Rewind( _lastMarker );
}
/** <summary>
* 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.
* </summary>
*/
public virtual void Seek( int index )
{
_p = index;
}
protected virtual T LB(int k)
{
if (k == 1)
return _previousElement;
throw new ArgumentException("can't look backwards more than one token in this stream");
}
}
}