public TemplateLexer(ErrorManager errMgr, ICharStream input, IToken templateToken, char delimiterStartChar, char delimiterStopChar)
{
this.errMgr = errMgr;
this.input = input;
c = (char)input.LA(1); // prime lookahead
this.templateToken = templateToken;
this.delimiterStartChar = delimiterStartChar;
this.delimiterStopChar = delimiterStopChar;
}
protected int ExecATN(ICharStream input, DFAState ds0)
{
//System.out.println("enter exec index "+input.index()+" from "+ds0.configs);
if (debug)
{
Console.WriteLine("start state closure=" + ds0.configSet);
}
if (ds0.isAcceptState)
{
// allow zero-length tokens
CaptureSimState(prevAccept, input, ds0);
}
int t = input.LA(1);
DFAState s = ds0; // s is current/from DFA state
while (true)
{ // while more work
if (debug)
{
Console.WriteLine("execATN loop starting closure: " + s.configSet);
}
// As we move src->trg, src->trg, we keep track of the previous trg to
// avoid looking up the DFA state again, which is expensive.
// If the previous target was already part of the DFA, we might
// be able to avoid doing a reach operation upon t. If s!=null,
// it means that semantic predicates didn't prevent us from
// creating a DFA state. Once we know s!=null, we check to see if
// the DFA state has an edge already for t. If so, we can just reuse
// it's configuration set; there's no point in re-computing it.
// This is kind of like doing DFA simulation within the ATN
// simulation because DFA simulation is really just a way to avoid
// computing reach/closure sets. Technically, once we know that
// we have a previously added DFA state, we could jump over to
// the DFA simulator. But, that would mean popping back and forth
// a lot and making things more complicated algorithmically.
// This optimization makes a lot of sense for loops within DFA.
// A character will take us back to an existing DFA state
// that already has lots of edges out of it. e.g., .* in comments.
DFAState target = GetExistingTargetState(s, t);
if (target == null)
{
target = ComputeTargetState(input, s, t);
}
if (target == ERROR)
{
break;
}
// If this is a consumable input element, make sure to consume before
// capturing the accept state so the input index, line, and char
// position accurately reflect the state of the interpreter at the
// end of the token.
if (t != IntStreamConstants.EOF)
{
Consume(input);
}
if (target.isAcceptState)
{
CaptureSimState(prevAccept, input, target);
if (t == IntStreamConstants.EOF)
{
break;
}
}
t = input.LA(1);
s = target; // flip; current DFA target becomes new src/from state
}
return FailOrAccept(prevAccept, input, s.configSet, t);
}
public void Consume(ICharStream input)
{
int curChar = input.LA(1);
if (curChar == '\n')
{
thisLine++;
charPositionInLine = 0;
}
else {
charPositionInLine++;
}
input.Consume();
}
protected int ExecATN(ICharStream input, DFAState ds0)
{
//System.out.println("enter exec index "+input.index()+" from "+ds0.configs);
if (debug)
{
ConsoleWriteLine("start state closure=" + ds0.configSet);
}
if (ds0.isAcceptState)
{
// allow zero-length tokens
CaptureSimState(prevAccept, input, ds0);
}
int t = input.LA(1);
DFAState s = ds0; // s is current/from DFA state
while (true)
{ // while more work
if (debug)
{
ConsoleWriteLine("execATN loop starting closure: " + s.configSet);
}
// As we move src->trg, src->trg, we keep track of the previous trg to
// avoid looking up the DFA state again, which is expensive.
// If the previous target was already part of the DFA, we might
// be able to avoid doing a reach operation upon t. If s!=null,
// it means that semantic predicates didn't prevent us from
// creating a DFA state. Once we know s!=null, we check to see if
// the DFA state has an edge already for t. If so, we can just reuse
// it's configuration set; there's no point in re-computing it.
// This is kind of like doing DFA simulation within the ATN
// simulation because DFA simulation is really just a way to avoid
// computing reach/closure sets. Technically, once we know that
// we have a previously added DFA state, we could jump over to
// the DFA simulator. But, that would mean popping back and forth
// a lot and making things more complicated algorithmically.
// This optimization makes a lot of sense for loops within DFA.
// A character will take us back to an existing DFA state
// that already has lots of edges out of it. e.g., .* in comments.
DFAState target = GetExistingTargetState(s, t);
if (target == null)
{
target = ComputeTargetState(input, s, t);
}
if (target == ERROR)
{
break;
}
// If this is a consumable input element, make sure to consume before
// capturing the accept state so the input index, line, and char
// position accurately reflect the state of the interpreter at the
// end of the token.
if (t != IntStreamConstants.EOF)
{
Consume(input);
}
if (target.isAcceptState)
{
CaptureSimState(prevAccept, input, target);
if (t == IntStreamConstants.EOF)
{
break;
}
}
t = input.LA(1);
s = target; // flip; current DFA target becomes new src/from state
}
return(FailOrAccept(prevAccept, input, s.configSet, t));
}
public int LA(int i)
{
var c = internalStream.LA(i);
return(c <= 0 ? c : (int)char.ToUpperInvariant((char)c));
}
public bool Check1()
{
return(Character.isJavaIdentifierStart(_input.LA(-1)));
}
