You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
162 lines
6.6 KiB
162 lines
6.6 KiB
/*
|
|
* [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
|
|
{
|
|
|
|
/** <summary>
|
|
* A simple stream of integers used when all I care about is the char
|
|
* or token type sequence (such as interpretation).
|
|
* </summary>
|
|
*/
|
|
public interface IIntStream
|
|
{
|
|
void Consume();
|
|
|
|
/** <summary>
|
|
* Get int at current input pointer + i ahead where i=1 is next int.
|
|
* Negative indexes are allowed. LA(-1) is previous token (token
|
|
* just matched). LA(-i) where i is before first token should
|
|
* yield -1, invalid char / EOF.
|
|
* </summary>
|
|
*/
|
|
int LA( int i );
|
|
|
|
/** <summary>
|
|
* Tell the stream to start buffering if it hasn't already. Return
|
|
* current input position, Index, or some other marker so that
|
|
* when passed to rewind() you get back to the same spot.
|
|
* rewind(mark()) should not affect the input cursor. The Lexer
|
|
* track line/col info as well as input index so its markers are
|
|
* not pure input indexes. Same for tree node streams.
|
|
* </summary>
|
|
*/
|
|
int Mark();
|
|
|
|
/** <summary>
|
|
* Return the current input symbol index 0..n where n indicates the
|
|
* last symbol has been read. The index is the symbol about to be
|
|
* read not the most recently read symbol.
|
|
* </summary>
|
|
*/
|
|
int Index
|
|
{
|
|
get;
|
|
}
|
|
|
|
/** <summary>
|
|
* Reset the stream so that next call to index would return marker.
|
|
* The marker will usually be Index but it doesn't have to be. It's
|
|
* just a marker to indicate what state the stream was in. This is
|
|
* essentially calling release() and seek(). If there are markers
|
|
* created after this marker argument, this routine must unroll them
|
|
* like a stack. Assume the state the stream was in when this marker
|
|
* was created.
|
|
* </summary>
|
|
*/
|
|
void Rewind( int marker );
|
|
|
|
/** <summary>
|
|
* Rewind to the input position of the last marker.
|
|
* Used currently only after a cyclic DFA and just
|
|
* before starting a sem/syn predicate to get the
|
|
* input position back to the start of the decision.
|
|
* Do not "pop" the marker off the state. mark(i)
|
|
* and rewind(i) should balance still. It is
|
|
* like invoking rewind(last marker) but it should not "pop"
|
|
* the marker off. It's like seek(last marker's input position).
|
|
* </summary>
|
|
*/
|
|
void Rewind();
|
|
|
|
/** <summary>
|
|
* You may want to commit to a backtrack but don't want to force the
|
|
* stream to keep bookkeeping objects around for a marker that is
|
|
* no longer necessary. This will have the same behavior as
|
|
* rewind() except it releases resources without the backward seek.
|
|
* This must throw away resources for all markers back to the marker
|
|
* argument. So if you're nested 5 levels of mark(), and then release(2)
|
|
* you have to release resources for depths 2..5.
|
|
* </summary>
|
|
*/
|
|
void Release( int marker );
|
|
|
|
/** <summary>
|
|
* Set the input cursor to the position indicated by index. This is
|
|
* normally used to seek ahead in the input stream. No buffering is
|
|
* required to do this unless you know your stream will use seek to
|
|
* move backwards such as when backtracking.
|
|
* </summary>
|
|
*
|
|
* <remarks>
|
|
* This is different from rewind in its multi-directional
|
|
* requirement and in that its argument is strictly an input cursor (index).
|
|
*
|
|
* For char streams, seeking forward must update the stream state such
|
|
* as line number. For seeking backwards, you will be presumably
|
|
* backtracking using the mark/rewind mechanism that restores state and
|
|
* so this method does not need to update state when seeking backwards.
|
|
*
|
|
* Currently, this method is only used for efficient backtracking using
|
|
* memoization, but in the future it may be used for incremental parsing.
|
|
*
|
|
* The index is 0..n-1. A seek to position i means that LA(1) will
|
|
* return the ith symbol. So, seeking to 0 means LA(1) will return the
|
|
* first element in the stream.
|
|
* </remarks>
|
|
*/
|
|
void Seek( int index );
|
|
|
|
/** <summary>
|
|
* Only makes sense for streams that buffer everything up probably, but
|
|
* might be useful to display the entire stream or for testing. This
|
|
* value includes a single EOF.
|
|
* </summary>
|
|
*/
|
|
int Count
|
|
{
|
|
get;
|
|
}
|
|
|
|
/** <summary>
|
|
* Where are you getting symbols from? Normally, implementations will
|
|
* pass the buck all the way to the lexer who can ask its input stream
|
|
* for the file name or whatever.
|
|
* </summary>
|
|
*/
|
|
string SourceName
|
|
{
|
|
get;
|
|
}
|
|
}
|
|
}
|