| /* |
| * [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)"); |
| } |
| } |
| } |
