private TemplateLexerMode CheckAnonymousTemplateForParameters()
{
int position = _input.Mark();
ClassifierLexerState currentState = State;
try
{
Mode = TemplateLexerMode.AnonymousTemplateParameters;
bool previousWasArg = false;
while (true)
{
IToken token = NextToken();
switch (token.Type)
{
case OutsideClassifierLexer.COMMA:
if (!previousWasArg)
{
return(TemplateLexerMode.Template);
}
previousWasArg = false;
continue;
case OutsideClassifierLexer.PARAMETER_DEFINITION:
case OutsideClassifierLexer.ID:
if (previousWasArg)
{
return(TemplateLexerMode.Template);
}
previousWasArg = true;
continue;
case OutsideClassifierLexer.PIPE:
if (previousWasArg)
{
return(TemplateLexerMode.AnonymousTemplateParameters);
}
return(TemplateLexerMode.Template);
case OutsideClassifierLexer.WS:
case OutsideClassifierLexer.COMMENT:
case OutsideClassifierLexer.NEWLINE:
continue;
default:
return(TemplateLexerMode.Template);
}
}
}
finally
{
_input.Rewind(position);
State = currentState;
}
}
private IToken subTemplate()
{
// look for "{ args ID (',' ID)* '|' ..."
subtemplateDepth++;
int m = input.Mark();
int curlyStartChar = startCharIndex;
int curlyLine = startLine;
int curlyPos = startCharPositionInLine;
List <IToken> argTokens = new List <IToken>();
consume();
IToken curly = newTokenFromPreviousChar(LCURLY);
WS();
argTokens.Add(mID());
WS();
while (c == ',')
{
consume();
argTokens.Add(newTokenFromPreviousChar(COMMA));
WS();
argTokens.Add(mID());
WS();
}
WS();
if (c == '|')
{
consume();
argTokens.Add(newTokenFromPreviousChar(PIPE));
if (isWS(c))
{
consume(); // ignore a single whitespace after |
}
//System.out.println("matched args: "+argTokens);
foreach (IToken t in argTokens)
{
emit(t);
}
input.Release(m);
scanningInsideExpr = false;
startCharIndex = curlyStartChar; // reset state
startLine = curlyLine;
startCharPositionInLine = curlyPos;
return(curly);
}
input.Rewind(m);
startCharIndex = curlyStartChar; // reset state
startLine = curlyLine;
startCharPositionInLine = curlyPos;
consume();
scanningInsideExpr = false;
return(curly);
}
private IToken NextTokenCore()
{
IToken token = null;
switch (Mode)
{
case AntlrClassifierLexerMode.Action:
if (ActionLevel == 1 && (InOptions || InTokens) && _input.LA(1) != '}')
{
goto case AntlrClassifierLexerMode.Grammar;
}
switch (_input.LA(1))
{
case '{':
token = _grammarLexer.NextToken();
ActionLevel++;
token.Type = AntlrGrammarClassifierLexer.ACTION;
break;
case '}':
token = _grammarLexer.NextToken();
ActionLevel--;
token.Type = AntlrGrammarClassifierLexer.ACTION;
if (ActionLevel == 0)
{
Mode = AntlrClassifierLexerMode.Grammar;
if (InOptions || InTokens)
{
token.Type = AntlrGrammarClassifierLexer.RCURLY;
InOptions = false;
InTokens = false;
}
}
break;
default:
token = _actionLexer.NextToken();
break;
}
break;
case AntlrClassifierLexerMode.ActionCharLiteral:
case AntlrClassifierLexerMode.ActionStringLiteral:
case AntlrClassifierLexerMode.ArgActionCharLiteral:
case AntlrClassifierLexerMode.ArgActionStringLiteral:
token = _actionLexer.NextToken();
break;
case AntlrClassifierLexerMode.ArgAction:
if (_input.LA(1) == ']')
{
token = _grammarLexer.NextToken();
Mode = AntlrClassifierLexerMode.Grammar;
}
else
{
token = _actionLexer.NextToken();
}
break;
case AntlrClassifierLexerMode.GrammarDoubleAngleStringLiteral:
token = _grammarLexer.NextToken();
break;
case AntlrClassifierLexerMode.Grammar:
default:
token = _grammarLexer.NextToken();
switch (token.Type)
{
case AntlrGrammarClassifierLexer.LCURLY:
ActionLevel++;
Mode = AntlrClassifierLexerMode.Action;
if ((!InOptions && !InTokens) || ActionLevel != 1)
{
token.Type = AntlrGrammarClassifierLexer.ACTION;
}
break;
case AntlrGrammarClassifierLexer.LBRACK:
Mode = AntlrClassifierLexerMode.ArgAction;
break;
case AntlrGrammarClassifierLexer.IDENTIFIER:
switch (token.Text)
{
case "options":
InOptions = true;
break;
case "tokens":
InTokens = true;
break;
default:
if (InOptions)
{
token.Type = AntlrGrammarClassifierLexer.OptionValue;
}
AntlrClassifierLexerState currentState = GetCurrentState();
int marker = _input.Mark();
try
{
while (true)
{
IToken nextToken = NextToken();
switch (nextToken.Type)
{
case AntlrGrammarClassifierLexer.NEWLINE:
case AntlrGrammarClassifierLexer.WS:
case AntlrGrammarClassifierLexer.COMMENT:
case AntlrGrammarClassifierLexer.DOC_COMMENT:
case AntlrGrammarClassifierLexer.ML_COMMENT:
case AntlrGrammarClassifierLexer.SL_COMMENT:
continue;
case AntlrGrammarClassifierLexer.ASSIGN:
if (InOptions)
{
if (IsValidOption(token.Text))
{
token.Type = AntlrGrammarClassifierLexer.ValidGrammarOption;
}
else
{
token.Type = AntlrGrammarClassifierLexer.InvalidGrammarOption;
}
}
else if (InTokens)
{
}
else
{
token.Type = AntlrGrammarClassifierLexer.LABEL;
}
break;
case AntlrGrammarClassifierLexer.PLUS_ASSIGN:
token.Type = AntlrGrammarClassifierLexer.LABEL;
break;
default:
break;
}
break;
}
}
finally
{
_input.Rewind(marker);
SetCurrentState(currentState);
}
break;
}
break;
default:
break;
}
break;
}
return(token);
}
