本文整理汇总了C#中IIntStream.Mark方法的典型用法代码示例。如果您正苦于以下问题：C# IIntStream.Mark方法的具体用法？C# IIntStream.Mark怎么用？C# IIntStream.Mark使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类IIntStream的用法示例。
在下文中一共展示了IIntStream.Mark方法的6个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: Predict
public virtual int Predict(IIntStream input)
{
int num6;
if (this.debug)
{
Console.Error.WriteLine("Enter DFA.predict for decision " + this.decisionNumber);
}
int marker = input.Mark();
int index = 0;
try
{
Label_0030:
if (this.debug)
{
Console.Error.WriteLine(string.Concat(new object[] { "DFA ", this.decisionNumber, " state ", index, " LA(1)=", (char) input.LA(1), "(", input.LA(1), "), index=", input.Index }));
}
int s = this.special[index];
if (s >= 0)
{
if (this.debug)
{
Console.Error.WriteLine(string.Concat(new object[] { "DFA ", this.decisionNumber, " state ", index, " is special state ", s }));
}
index = this.SpecialStateTransition(this, s, input);
if (this.debug)
{
Console.Error.WriteLine(string.Concat(new object[] { "DFA ", this.decisionNumber, " returns from special state ", s, " to ", index }));
}
if (index == -1)
{
this.NoViableAlt(index, input);
return 0;
}
input.Consume();
goto Label_0030;
}
if (this.accept[index] >= 1)
{
if (this.debug)
{
Console.Error.WriteLine(string.Concat(new object[] { "accept; predict ", this.accept[index], " from state ", index }));
}
return this.accept[index];
}
char ch = (char) input.LA(1);
if ((ch >= this.min[index]) && (ch <= this.max[index]))
{
int num4 = this.transition[index][ch - this.min[index]];
if (num4 < 0)
{
if (this.eot[index] < 0)
{
this.NoViableAlt(index, input);
return 0;
}
if (this.debug)
{
Console.Error.WriteLine("EOT transition");
}
index = this.eot[index];
input.Consume();
}
else
{
index = num4;
input.Consume();
}
goto Label_0030;
}
if (this.eot[index] >= 0)
{
if (this.debug)
{
Console.Error.WriteLine("EOT transition");
}
index = this.eot[index];
input.Consume();
goto Label_0030;
}
if ((ch == 0xffff) && (this.eof[index] >= 0))
{
if (this.debug)
{
Console.Error.WriteLine(string.Concat(new object[] { "accept via EOF; predict ", this.accept[this.eof[index]], " from ", this.eof[index] }));
}
return this.accept[this.eof[index]];
}
if (this.debug)
{
Console.Error.WriteLine(string.Concat(new object[] { "min[", index, "]=", this.min[index] }));
Console.Error.WriteLine(string.Concat(new object[] { "max[", index, "]=", this.max[index] }));
Console.Error.WriteLine(string.Concat(new object[] { "eot[", index, "]=", this.eot[index] }));
Console.Error.WriteLine(string.Concat(new object[] { "eof[", index, "]=", this.eof[index] }));
for (int i = 0; i < this.transition[index].Length; i++)
{
Console.Error.Write(this.transition[index][i] + " ");
}
Console.Error.WriteLine();
}
this.NoViableAlt(index, input);
//.........这里部分代码省略.........
示例2: RecognitionException
public RecognitionException(string message, IIntStream input, int k, Exception innerException)
: base(message, innerException)
{
this._input = input;
this._k = k;
if (input != null)
{
this._index = input.Index + k - 1;
if (input is ITokenStream)
{
this._token = ((ITokenStream)input).LT(k);
this._line = _token.Line;
this._charPositionInLine = _token.CharPositionInLine;
}
ITreeNodeStream tns = input as ITreeNodeStream;
if (tns != null)
{
ExtractInformationFromTreeNodeStream(tns, k);
}
else
{
ICharStream charStream = input as ICharStream;
if (charStream != null)
{
int mark = input.Mark();
try
{
for (int i = 0; i < k - 1; i++)
input.Consume();
this._c = input.LA(1);
this._line = ((ICharStream)input).Line;
this._charPositionInLine = ((ICharStream)input).CharPositionInLine;
}
finally
{
input.Rewind(mark);
}
}
else
{
this._c = input.LA(k);
}
}
}
}示例3: Predict
/** <summary>
* From the input stream, predict what alternative will succeed
* using this DFA (representing the covering regular approximation
* to the underlying CFL). Return an alternative number 1..n. Throw
* an exception upon error.
* </summary>
*/
public virtual int Predict( IIntStream input )
{
if ( debug )
{
Console.Error.WriteLine( "Enter DFA.predict for decision " + decisionNumber );
}
int mark = input.Mark(); // remember where decision started in input
int s = 0; // we always start at s0
try
{
for ( ; ; )
{
if ( debug )
Console.Error.WriteLine( "DFA " + decisionNumber + " state " + s + " LA(1)=" + (char)input.LA( 1 ) + "(" + input.LA( 1 ) +
"), index=" + input.Index );
int specialState = special[s];
if ( specialState >= 0 )
{
if ( debug )
{
Console.Error.WriteLine( "DFA " + decisionNumber +
" state " + s + " is special state " + specialState );
}
s = SpecialStateTransition( this, specialState, input );
if ( debug )
{
Console.Error.WriteLine( "DFA " + decisionNumber +
" returns from special state " + specialState + " to " + s );
}
if ( s == -1 )
{
NoViableAlt( s, input );
return 0;
}
input.Consume();
continue;
}
if ( accept[s] >= 1 )
{
if ( debug )
Console.Error.WriteLine( "accept; predict " + accept[s] + " from state " + s );
return accept[s];
}
// look for a normal char transition
char c = (char)input.LA( 1 ); // -1 == \uFFFF, all tokens fit in 65000 space
if ( c >= min[s] && c <= max[s] )
{
int snext = transition[s][c - min[s]]; // move to next state
if ( snext < 0 )
{
// was in range but not a normal transition
// must check EOT, which is like the else clause.
// eot[s]>=0 indicates that an EOT edge goes to another
// state.
if ( eot[s] >= 0 )
{ // EOT Transition to accept state?
if ( debug )
Console.Error.WriteLine( "EOT transition" );
s = eot[s];
input.Consume();
// TODO: I had this as return accept[eot[s]]
// which assumed here that the EOT edge always
// went to an accept...faster to do this, but
// what about predicated edges coming from EOT
// target?
continue;
}
NoViableAlt( s, input );
return 0;
}
s = snext;
input.Consume();
continue;
}
if ( eot[s] >= 0 )
{ // EOT Transition?
if ( debug )
Console.Error.WriteLine( "EOT transition" );
s = eot[s];
input.Consume();
continue;
}
if ( c == unchecked((char)TokenConstants.EOF) && eof[s] >= 0 )
{ // EOF Transition to accept state?
if ( debug )
Console.Error.WriteLine( "accept via EOF; predict " + accept[eof[s]] + " from " + eof[s] );
return accept[eof[s]];
}
// not in range and not EOF/EOT, must be invalid symbol
if ( debug )
{
Console.Error.WriteLine( "min[" + s + "]=" + min[s] );
Console.Error.WriteLine( "max[" + s + "]=" + max[s] );
//.........这里部分代码省略.........
示例4: Predict
/** <summary>
* From the input stream, predict what alternative will succeed
* using this DFA (representing the covering regular approximation
* to the underlying CFL). Return an alternative number 1..n. Throw
* an exception upon error.
* </summary>
*/
public virtual int Predict( IIntStream input )
{
if (input == null)
throw new ArgumentNullException("input");
DfaDebugMessage("Enter DFA.Predict for decision {0}", decisionNumber);
int mark = input.Mark(); // remember where decision started in input
int s = 0; // we always start at s0
try
{
while (true)
{
DfaDebugMessage("DFA {0} state {1} LA(1)={2}({3}), index={4}", decisionNumber, s, (char)input.LA(1), input.LA(1), input.Index);
int specialState = special[s];
if ( specialState >= 0 )
{
DfaDebugMessage("DFA {0} state {1} is special state {2}", decisionNumber, s, specialState);
s = SpecialStateTransition( this, specialState, input );
DfaDebugMessage("DFA {0} returns from special state {1} to {2}", decisionNumber, specialState, s);
if ( s == -1 )
{
NoViableAlt( s, input );
return 0;
}
input.Consume();
continue;
}
if ( accept[s] >= 1 )
{
DfaDebugMessage("accept; predict {0} from state {1}", accept[s], s);
return accept[s];
}
// look for a normal char transition
char c = (char)input.LA( 1 ); // -1 == \uFFFF, all tokens fit in 65000 space
if ( c >= min[s] && c <= max[s] )
{
int snext = transition[s][c - min[s]]; // move to next state
if ( snext < 0 )
{
// was in range but not a normal transition
// must check EOT, which is like the else clause.
// eot[s]>=0 indicates that an EOT edge goes to another
// state.
if ( eot[s] >= 0 )
{
// EOT Transition to accept state?
DfaDebugMessage("EOT transition");
s = eot[s];
input.Consume();
// TODO: I had this as return accept[eot[s]]
// which assumed here that the EOT edge always
// went to an accept...faster to do this, but
// what about predicated edges coming from EOT
// target?
continue;
}
NoViableAlt( s, input );
return 0;
}
s = snext;
input.Consume();
continue;
}
if ( eot[s] >= 0 )
{
// EOT Transition?
DfaDebugMessage("EOT transition");
s = eot[s];
input.Consume();
continue;
}
if ( c == unchecked( (char)TokenTypes.EndOfFile ) && eof[s] >= 0 )
{
// EOF Transition to accept state?
DfaDebugMessage("accept via EOF; predict {0} from {1}", accept[eof[s]], eof[s]);
return accept[eof[s]];
}
// not in range and not EOF/EOT, must be invalid symbol
DfaDebugInvalidSymbol(s);
//.........这里部分代码省略.........
示例5: ParseEngine
/** Fill a list of all NFA states visited during the parse */
protected virtual void ParseEngine( String startRule,
NFAState start,
NFAState stop,
IIntStream input,
Stack<object> ruleInvocationStack,
IDebugEventListener actions,
IList visitedStates )
{
NFAState s = start;
if ( actions != null )
{
actions.EnterRule( s.nfa.grammar.FileName, start.enclosingRule.Name );
}
int t = input.LA( 1 );
while ( s != stop )
{
if ( visitedStates != null )
{
visitedStates.Add( s );
}
//Console.Out.WriteLine( "parse state " + s.stateNumber + " input=" + s.nfa.grammar.getTokenDisplayName( t ) );
// CASE 1: decision state
if ( s.DecisionNumber > 0 && s.nfa.grammar.GetNumberOfAltsForDecisionNFA( s ) > 1 )
{
// decision point, must predict and jump to alt
DFA dfa = s.nfa.grammar.GetLookaheadDFA( s.DecisionNumber );
//if ( s.nfa.grammar.type != GrammarType.Lexer )
//{
// Console.Out.WriteLine( "decision: " +
// dfa.getNFADecisionStartState().Description +
// " input=" + s.nfa.grammar.getTokenDisplayName( t ) );
//}
int m = input.Mark();
int predictedAlt = Predict( dfa );
if ( predictedAlt == NFA.INVALID_ALT_NUMBER )
{
String description = dfa.NFADecisionStartState.Description;
NoViableAltException nvae =
new NoViableAltException( description,
dfa.DecisionNumber,
s.stateNumber,
input );
if ( actions != null )
{
actions.RecognitionException( nvae );
}
input.Consume(); // recover
throw nvae;
}
input.Rewind( m );
int parseAlt =
s.TranslateDisplayAltToWalkAlt( predictedAlt );
//if ( s.nfa.grammar.type != GrammarType.Lexer )
//{
// Console.Out.WriteLine( "predicted alt " + predictedAlt + ", parseAlt " + parseAlt );
//}
NFAState alt;
if ( parseAlt > s.nfa.grammar.GetNumberOfAltsForDecisionNFA( s ) )
{
// implied branch of loop etc...
alt = s.nfa.grammar.nfa.GetState( s.endOfBlockStateNumber );
}
else
{
alt = s.nfa.grammar.GetNFAStateForAltOfDecision( s, parseAlt );
}
s = (NFAState)alt.transition[0].target;
continue;
}
// CASE 2: finished matching a rule
if ( s.IsAcceptState )
{ // end of rule node
if ( actions != null )
{
actions.ExitRule( s.nfa.grammar.FileName, s.enclosingRule.Name );
}
if ( ruleInvocationStack.Count == 0 )
{
// done parsing. Hit the start state.
//Console.Out.WriteLine( "stack empty in stop state for " + s.enclosingRule );
break;
}
// pop invoking state off the stack to know where to return to
NFAState invokingState = (NFAState)ruleInvocationStack.Pop();
RuleClosureTransition invokingTransition =
(RuleClosureTransition)invokingState.transition[0];
// move to node after state that invoked this rule
s = invokingTransition.followState;
continue;
}
Transition trans = s.transition[0];
Label label = trans.label;
if ( label.IsSemanticPredicate )
{
FailedPredicateException fpe =
new FailedPredicateException( input,
s.enclosingRule.Name,
//.........这里部分代码省略.........
示例6: Predict
/// <summary>
/// From the input stream, predict what alternative will succeed using this
/// DFA (representing the covering regular approximation to the underlying CFL).
/// </summary>
/// <param name="input">Input stream</param>
/// <returns>Return an alternative number 1..n. Throw an exception upon error.</returns>
public int Predict(IIntStream input)
{
int mark = input.Mark(); // remember where decision started in input
int s = 0; // we always start at s0
try
{
while (true)
{
int specialState = special[s];
if (specialState >= 0)
{
s = specialStateTransitionHandler(this, specialState, input);
if (s == -1)
{
NoViableAlt(s, input);
return 0;
}
input.Consume();
continue;
}
if (accept[s] >= 1)
{
return accept[s];
}
// look for a normal char transition
char c = (char)input.LA(1); // -1 == \uFFFF, all tokens fit in 65000 space
if ((c >= min[s]) && (c <= max[s]))
{
int snext = transition[s][c - min[s]]; // move to next state
if (snext < 0)
{
// was in range but not a normal transition
// must check EOT, which is like the else clause.
// eot[s]>=0 indicates that an EOT edge goes to another
// state.
if (eot[s] >= 0) // EOT Transition to accept state?
{
s = eot[s];
input.Consume();
// TODO: I had this as return accept[eot[s]]
// which assumed here that the EOT edge always
// went to an accept...faster to do this, but
// what about predicated edges coming from EOT
// target?
continue;
}
NoViableAlt(s, input);
return 0;
}
s = snext;
input.Consume();
continue;
}
if (eot[s] >= 0)
{ // EOT Transition?
s = eot[s];
input.Consume();
continue;
}
if ((c == (char)Token.EOF) && (eof[s] >= 0))
{ // EOF Transition to accept state?
return accept[eof[s]];
}
// not in range and not EOF/EOT, must be invalid symbol
NoViableAlt(s, input);
return 0;
}
}
finally
{
input.Rewind(mark);
}
}