diff options
Diffstat (limited to 'runtime/CSharp2/Sources/Antlr3.Runtime/Antlr.Runtime/RecognizerSharedState.cs')
| -rw-r--r-- | runtime/CSharp2/Sources/Antlr3.Runtime/Antlr.Runtime/RecognizerSharedState.cs | 182 |
1 files changed, 182 insertions, 0 deletions
diff --git a/runtime/CSharp2/Sources/Antlr3.Runtime/Antlr.Runtime/RecognizerSharedState.cs b/runtime/CSharp2/Sources/Antlr3.Runtime/Antlr.Runtime/RecognizerSharedState.cs new file mode 100644 index 0000000..5395110 --- /dev/null +++ b/runtime/CSharp2/Sources/Antlr3.Runtime/Antlr.Runtime/RecognizerSharedState.cs @@ -0,0 +1,182 @@ +/* + * [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 { + using System.Collections.Generic; + using CLSCompliant = System.CLSCompliantAttribute; + using ArgumentNullException = System.ArgumentNullException; + + /** <summary> + * The set of fields needed by an abstract recognizer to recognize input + * and recover from errors etc... As a separate state object, it can be + * shared among multiple grammars; e.g., when one grammar imports another. + * </summary> + * + * <remarks> + * These fields are publically visible but the actual state pointer per + * parser is protected. + * </remarks> + */ + public class RecognizerSharedState { + /** <summary> + * Track the set of token types that can follow any rule invocation. + * Stack grows upwards. When it hits the max, it grows 2x in size + * and keeps going. + * </summary> + */ + //public List<BitSet> following; + public BitSet[] following; + [CLSCompliant(false)] + public int _fsp; + + /** <summary> + * This is true when we see an error and before having successfully + * matched a token. Prevents generation of more than one error message + * per error. + * </summary> + */ + public bool errorRecovery; + + /** <summary> + * The index into the input stream where the last error occurred. + * This is used to prevent infinite loops where an error is found + * but no token is consumed during recovery...another error is found, + * ad naseum. This is a failsafe mechanism to guarantee that at least + * one token/tree node is consumed for two errors. + * </summary> + */ + public int lastErrorIndex; + + /** <summary> + * In lieu of a return value, this indicates that a rule or token + * has failed to match. Reset to false upon valid token match. + * </summary> + */ + public bool failed; + + /** <summary>Did the recognizer encounter a syntax error? Track how many.</summary> */ + public int syntaxErrors; + + /** <summary> + * If 0, no backtracking is going on. Safe to exec actions etc... + * If >0 then it's the level of backtracking. + * </summary> + */ + public int backtracking; + + /** <summary> + * An array[size num rules] of Map<Integer,Integer> that tracks + * the stop token index for each rule. ruleMemo[ruleIndex] is + * the memoization table for ruleIndex. For key ruleStartIndex, you + * get back the stop token for associated rule or MEMO_RULE_FAILED. + * </summary> + * + * <remarks>This is only used if rule memoization is on (which it is by default).</remarks> + */ + public IDictionary<int, int>[] ruleMemo; + + + // LEXER FIELDS (must be in same state object to avoid casting + // constantly in generated code and Lexer object) :( + + + /** <summary> + * The goal of all lexer rules/methods is to create a token object. + * This is an instance variable as multiple rules may collaborate to + * create a single token. nextToken will return this object after + * matching lexer rule(s). If you subclass to allow multiple token + * emissions, then set this to the last token to be matched or + * something nonnull so that the auto token emit mechanism will not + * emit another token. + * </summary> + */ + public IToken token; + + /** <summary> + * What character index in the stream did the current token start at? + * Needed, for example, to get the text for current token. Set at + * the start of nextToken. + * </summary> + */ + public int tokenStartCharIndex; + + /** <summary>The line on which the first character of the token resides</summary> */ + public int tokenStartLine; + + /** <summary>The character position of first character within the line</summary> */ + public int tokenStartCharPositionInLine; + + /** <summary>The channel number for the current token</summary> */ + public int channel; + + /** <summary>The token type for the current token</summary> */ + public int type; + + /** <summary> + * You can set the text for the current token to override what is in + * the input char buffer. Use setText() or can set this instance var. + * </summary> + */ + public string text; + + public RecognizerSharedState() { + //following = new List<BitSet>( BaseRecognizer.InitialFollowStackSize ); + following = new BitSet[BaseRecognizer.InitialFollowStackSize]; + _fsp = -1; + lastErrorIndex = -1; + tokenStartCharIndex = -1; + } + + public RecognizerSharedState(RecognizerSharedState state) { + if (state == null) + throw new ArgumentNullException("state"); + + following = (BitSet[])state.following.Clone(); + _fsp = state._fsp; + errorRecovery = state.errorRecovery; + lastErrorIndex = state.lastErrorIndex; + failed = state.failed; + syntaxErrors = state.syntaxErrors; + backtracking = state.backtracking; + + if (state.ruleMemo != null) + ruleMemo = (IDictionary<int, int>[])state.ruleMemo.Clone(); + + token = state.token; + tokenStartCharIndex = state.tokenStartCharIndex; + tokenStartCharPositionInLine = state.tokenStartCharPositionInLine; + channel = state.channel; + type = state.type; + text = state.text; + } + } +} |