private static Pair<string, int> FindScriptName(
int start,
ITokenStream tokens)
{
string lastIdent = null;
var lastIdentIndex = 0;
for (var i = start; i < tokens.Size; i++)
{
if (tokens.Get(i).Type == EsperEPL2GrammarParser.IDENT)
{
lastIdent = tokens.Get(i).Text;
lastIdentIndex = i;
}
if (tokens.Get(i).Type == EsperEPL2GrammarParser.LPAREN)
{
break;
}
// find beginning of script, ignore brackets
if (tokens.Get(i).Type == EsperEPL2GrammarParser.LBRACK && tokens.Get(i + 1).Type != EsperEPL2GrammarParser.RBRACK)
{
break;
}
}
if (lastIdent == null)
{
throw new IllegalStateException("Failed to parse expression name");
}
return new Pair<string, int>(lastIdent, lastIdentIndex);
}
private static bool IsContainsScriptOrClassExpression(ITokenStream tokens)
{
for (var i = 0; i < tokens.Size; i++)
{
if (tokens.Get(i).Type == EsperEPL2GrammarParser.CLASSDECL) {
int startTokenTripleQuote = FindTokenClass(i + 1, tokens);
if (startTokenTripleQuote != -1) {
int endTokenTripleQuote = FindTokenClass(startTokenTripleQuote + 1, tokens);
if (endTokenTripleQuote != -1) {
return true;
}
}
}
if (tokens.Get(i).Type == EsperEPL2GrammarParser.EXPRESSIONDECL)
{
var startTokenLcurly = FindStartTokenScript(i + 1, tokens, EsperEPL2GrammarParser.LCURLY);
var startTokenLbrack = FindStartTokenScript(i + 1, tokens, EsperEPL2GrammarParser.LBRACK);
// Handle:
// expression ABC { some[other] }
// expression boolean js:doit(...) [ {} ]
if (startTokenLbrack != -1 && (startTokenLcurly == -1 || startTokenLcurly > startTokenLbrack))
{
return true;
}
}
}
return false;
}
/// <summary>Returns true if on the current index of the parser's
/// token stream a token of the given type exists on the
/// Hidden channel.
/// </summary>
/// <param name="type">
/// The type of the token on the Hidden channel to check.
/// </param>
protected bool here(int type)
{
// Get the token ahead of the current index.
int possibleIndexEosToken = CurrentToken.TokenIndex - 1;
IToken ahead = _input.Get(possibleIndexEosToken);
// Check if the token resides on the Hidden channel and if it's of the
// provided type.
return(ahead.Channel == Lexer.Hidden && ahead.Type == type);
}
private static Interval GetSourceInterval(ITree tree, ITokenStream tokenStream)
{
Contract.Requires(tree != null);
Contract.Requires(tokenStream != null);
IToken firstToken = tokenStream.Get(tree.TokenStartIndex);
IToken lastToken = tokenStream.Get(tree.TokenStopIndex);
return(Interval.FromBounds(firstToken.StartIndex, lastToken.StopIndex));
}
private static int FindEndTokenScript(
int startIndex,
ITokenStream tokens,
int tokenTypeSearch,
ISet<int> afterScriptTokens,
bool requireAfterScriptToken)
{
// The next non-comment token must be among the afterScriptTokens, i.e. SELECT/INSERT/ON/DELETE/UPDATE
// Find next non-comment token.
if (requireAfterScriptToken)
{
var found = -1;
for (var i = startIndex; i < tokens.Size; i++)
{
if (tokens.Get(i).Type == tokenTypeSearch)
{
for (var j = i + 1; j < tokens.Size; j++)
{
var next = tokens.Get(j);
if (next.Channel == 0)
{
if (afterScriptTokens.Contains(next.Type))
{
found = i;
}
break;
}
}
}
if (found != -1)
{
break;
}
}
return found;
}
// Find the last token
var indexLast = -1;
for (var i = startIndex; i < tokens.Size; i++)
{
if (tokens.Get(i).Type == tokenTypeSearch)
{
indexLast = i;
}
}
return indexLast;
}
private TokenLocation GetLocation(ISyntaxTree node)
{
var interval = node.SourceInterval;
if (interval.Length == 0)
{
return(new TokenLocation(tokenStream.Get(0), tokenStream.Get(0)));
}
var start = tokenStream.Get(interval.a);
var end = tokenStream.Get(interval.b);
return(new TokenLocation(start, end));
}
/// <summary>
/// Output all unprocessed whitespace tokens in the given token stream index range
/// </summary>
protected void WriteWhiteSpace(int minIndex, int maxIndex)
{
IToken token;
for (int index = minIndex; index <= maxIndex; index++)
{
token = _tokens.Get(index);
if (IsWhiteSpace(token))
{
WriteWhitespaceToken(token);
}
}
}
public static IEnumerable <IToken> AllTokens(ITokenStream ts)
{
for (int i = 0; i < ts.Size; ++i)
{
yield return(ts.Get(i));
}
}
public static string MakeMessage(Module module, IParseTree place, ITokenStream tokens, string msg)
{
var interval = place.SourceInterval;
var begin = tokens.Get(interval.a);
return(MakeMessage(module.file_path, begin.Line, begin.Column, msg));
}
/** Find stop token index of next operator; return -1 if not operator. */
public static int getLastOpTokenIndex(ITokenStream tokens)
{
var i = tokens.Index; // current on-channel lookahead token index
var lt = tokens.Get(i);
if (lt.getType() == SwiftParser.DOT && tokens.get(i + 1).getType() == SwiftParser.DOT)
{
// dot-operator
i += 2; // point at token after ".."
lt = tokens.get(i);
while (lt.getType() != Token.EOF &&
(lt.getType() == SwiftParser.DOT || isOperatorChar(lt.getType())))
{
i++;
lt = tokens.get(i);
}
return(i - 1);
}
// Is it regular operator?
if (!isOperatorHead(lt.getType()))
{
return(-1);
}
i++;
lt = tokens.get(i);
while (lt.getType() != Token.EOF && isOperatorChar(lt.getType()))
{
i++;
lt = tokens.get(i);
}
int stop = i - 1;
return(stop);
}
public virtual void Emit(CommonTree opAST, Bytecode opcode)
{
EnsureCapacity(1);
if (opAST != null)
{
int i = opAST.TokenStartIndex;
int j = opAST.TokenStopIndex;
int p = tokens.Get(i).StartIndex;
int q = tokens.Get(j).StopIndex;
if (!(p < 0 || q < 0))
{
impl.sourceMap[ip] = Interval.FromBounds(p, q + 1);
}
}
impl.instrs[ip++] = (byte)opcode;
}
public override string ToString()
{
string opName = GetType().FullName;
int index = opName.IndexOf('$');
opName = Sharpen.Runtime.Substring(opName, index + 1, opName.Length);
return("<" + opName + "@" + tokens.Get(this.index) + ":\"" + text + "\">");
}
IToken ScanForLastToken(int type, int start, ITokenStream TokenStream, out int iLast)
{
var lastFound = TokenStream.Get(start);
int iLine = lastFound.Line;
iLast = start;
IToken nextToken = lastFound;
IToken nextToken2 = lastFound;
for (int i = start + 1; i < TokenStream.Size - 2; i++)
{
nextToken = TokenStream.Get(i);
nextToken2 = TokenStream.Get(i + 2); // STATIC <WS> DEFINE for example.
if (nextToken.Line > iLine)
{
if (nextToken.Type == type || (nextToken2.Type == type && nextToken.Type == XSharpLexer.STATIC))
{
lastFound = nextToken;
iLine = nextToken.Line;
iLast = i;
}
else if (nextToken.Type != XSharpLexer.WS)
{
break;
}
}
}
nextToken = lastFound;
for (int i = iLast; i < TokenStream.Size; i++)
{
nextToken = TokenStream.Get(i);
if (nextToken.Line == lastFound.Line &&
nextToken.Type != XSharpLexer.NL &&
nextToken.Type != XSharpLexer.EOS)
{
lastFound = nextToken;
}
else
{
break;
}
}
return(lastFound);
}
private static int FindTokenClass(
int startIndex,
ITokenStream tokens)
{
int found = -1;
for (int i = startIndex; i < tokens.Size; i++) {
if (tokens.Get(i).Type == EsperEPL2GrammarParser.TRIPLEQUOTE) {
return i;
}
}
return found;
}
public virtual void Consume()
{
if (initialStreamState)
{
ConsumeInitialHiddenTokens();
}
int a = input.Index;
IToken t = input.LT(1);
input.Consume();
int b = input.Index;
dbg.ConsumeToken(t);
if (b > a + 1)
{
// then we consumed more than one token; must be off channel tokens
for (int i = a + 1; i < b; i++)
{
dbg.ConsumeHiddenToken(input.Get(i));
}
}
}
public static Range GetRange(this CommonTree node, ITokenStream tokenStream, IReadOnlyScriptText scriptText)
{
if (node is CommonErrorNode errorNode)
{
return(new Range()
{
Start = scriptText.PositionAt(((CommonToken)tokenStream.Get(errorNode.start.TokenIndex)).StartIndex),
End = scriptText.PositionAt(((CommonToken)tokenStream.Get(errorNode.stop.TokenIndex)).StopIndex + 1)
});
}
if (node.TokenStartIndex == -1 || node.TokenStopIndex == -1)
{
return(Range.Empty);
}
return(new Range()
{
Start = scriptText.PositionAt(((CommonToken)tokenStream.Get(node.TokenStartIndex)).StartIndex),
End = scriptText.PositionAt(((CommonToken)tokenStream.Get(node.TokenStopIndex)).StopIndex + 1)
});
}
public static boolean isOpNext(ITokenStream tokens)
{
var start = tokens.Index;
var lt = tokens.Get(start);
var stop = getLastOpTokenIndex(tokens);
if (stop == -1)
{
return(false);
}
Console.WriteLine("isOpNext: i={0} t='{1}'", start, lt.getText());
Console.WriteLine(", op='{0}'\n", tokens.GetText(Interval.Of(start, stop)));
return(true);
}
/** <summary>Get num hidden tokens between i..j inclusive</summary> */
public virtual int GetNumberOfHiddenTokens(int i, int j)
{
int n = 0;
ITokenStream input = parser.TokenStream;
for (int ti = i; ti < input.Size() && ti <= j; ti++)
{
IToken t = input.Get(ti);
if (t.Channel != TokenConstants.DEFAULT_CHANNEL)
{
n++;
}
}
return(n);
}
/** Get num hidden tokens between i..j inclusive */
public virtual int GetNumberOfHiddenTokens(int i, int j)
{
int n = 0;
ITokenStream input = parser.TokenStream;
for (int ti = i; ti < input.Count && ti <= j; ti++)
{
IToken t = input.Get(ti);
if (t.Channel != TokenChannels.Default)
{
n++;
}
}
return(n);
}
/// <summary>
/// Input an expression token in tree structure, return a single token representing the whole expression
/// </summary>
/// <param name="rootToken"></param>
/// <param name="input"></param>
/// <returns></returns>
public static IToken GetExpressionToken(CommonTree rootToken, ITreeNodeStream input)
{
try
{
ITokenStream stream = ((Antlr.Runtime.Tree.CommonTreeNodeStream)(input)).TokenStream;
int start = rootToken.TokenStartIndex;
int end = rootToken.TokenStopIndex;
IToken token1 = new CommonToken(); //(Token.DEFAULT_CHANNEL
token1.CharPositionInLine = stream.Get(start).CharPositionInLine;
token1.Line = stream.Get(start).Line;
for (int i = start; i <= end; i++)
{
token1.Text += stream.Get(i).Text;
}
return(token1);
}
catch (Exception)
{
}
return(rootToken.Token);
}
private static int FindStartTokenScript(
int startIndex,
ITokenStream tokens,
int tokenTypeSearch)
{
var found = -1;
for (var i = startIndex; i < tokens.Size; i++)
{
if (tokens.Get(i).Type == tokenTypeSearch)
{
return i;
}
}
return found;
}
public IToken GetToken(int index)
{
ITokenStream tokenStream = TokenStream;
if (tokenStream == null)
{
return(null);
}
if (index < 0 || index >= tokenStream.Count)
{
return(null);
}
return(_tokenStream.Get(index));
}
public TokenStreamVisualizerForm(ITokenStream tokenStream)
{
if (tokenStream == null)
{
throw new ArgumentNullException("tokenStream");
}
InitializeComponent();
List <IToken> tokens = new List <IToken>();
int marker = tokenStream.Mark();
int currentPosition = tokenStream.Index;
try
{
tokenStream.Seek(0);
while (tokenStream.LA(1) != CharStreamConstants.EndOfFile)
{
tokenStream.Consume();
}
for (int i = 0; i < tokenStream.Count; i++)
{
tokens.Add(tokenStream.Get(i));
}
}
finally
{
tokenStream.Rewind(marker);
}
this._tokenStream = tokenStream;
this._tokens = tokens.ToArray();
if (tokenStream.TokenSource != null)
{
this._tokenNames = tokenStream.TokenSource.TokenNames;
}
this._tokenNames = this._tokenNames ?? new string[0];
UpdateTokenTypes();
UpdateHighlighting();
listBox1.BackColor = Color.Wheat;
}
private static IToken GetTokenBefore(
int i,
ITokenStream tokens)
{
var position = i - 1;
while (position >= 0)
{
var t = tokens.Get(position);
if (t.Channel != 99 && t.Type != EsperEPL2GrammarLexer.WS)
{
return t;
}
position--;
}
return null;
}
public TokenStreamVisualizerForm( ITokenStream tokenStream )
{
if (tokenStream == null)
throw new ArgumentNullException("tokenStream");
InitializeComponent();
List<IToken> tokens = new List<IToken>();
int marker = tokenStream.Mark();
int currentPosition = tokenStream.Index;
try
{
tokenStream.Seek(0);
while (tokenStream.LA(1) != CharStreamConstants.EndOfFile)
tokenStream.Consume();
for (int i = 0; i < tokenStream.Count; i++)
tokens.Add(tokenStream.Get(i));
}
finally
{
tokenStream.Rewind(marker);
}
this._tokenStream = tokenStream;
this._tokens = tokens.ToArray();
if (tokenStream.TokenSource != null)
this._tokenNames = tokenStream.TokenSource.TokenNames;
this._tokenNames = this._tokenNames ?? new string[0];
UpdateTokenTypes();
UpdateHighlighting();
listBox1.BackColor = Color.Wheat;
}
public override void EnterDecision(int decisionNumber, bool couldBacktrack)
{
lastRealTokenTouchedInDecision = null;
stats.numDecisionEvents++;
int startingLookaheadIndex = parser.TokenStream.Index;
ITokenStream input = parser.TokenStream;
if (dump)
{
Console.WriteLine("enterDecision canBacktrack=" + couldBacktrack + " " + decisionNumber +
" backtrack depth " + backtrackDepth +
" @ " + input.Get(input.Index) +
" rule " + LocationDescription());
}
string g = currentGrammarFileName.Peek();
DecisionDescriptor descriptor = decisions.Get(g, decisionNumber);
if (descriptor == null)
{
descriptor = new DecisionDescriptor();
decisions.Put(g, decisionNumber, descriptor);
descriptor.decision = decisionNumber;
descriptor.fileName = currentGrammarFileName.Peek();
descriptor.ruleName = currentRuleName.Peek();
descriptor.line = currentLine.Peek();
descriptor.pos = currentPos.Peek();
descriptor.couldBacktrack = couldBacktrack;
}
descriptor.n++;
DecisionEvent d = new DecisionEvent();
decisionStack.Push(d);
d.decision = descriptor;
d.startTime = DateTime.Now;
d.startIndex = startingLookaheadIndex;
}
public override LessNode VisitSelectorElement(LessParser.SelectorElementContext context)
{
IEnumerable <IdentifierPart> GetIdentifierParts()
{
string prefix = context.HASH()?.GetText()
?? context.DOT()?.GetText();
foreach (var identifierPart in this.GetIdentifierParts(prefix, context.identifier()))
{
yield return(identifierPart);
}
}
Identifier GetPseudoclassIdentifier()
{
var pseudo = context.pseudoClass();
if (pseudo == null)
{
return(null);
}
string prefix = pseudo.COLON()?.GetText()
?? pseudo.COLONCOLON()?.GetText()
?? "";
return(new Identifier(new PseudoclassIdentifierPart(prefix, pseudo.pseudoclassIdentifier().GetText(),
(Expression)pseudo.expression()?.Accept(this))));
}
Identifier GetIdentifier()
{
return(new Identifier(GetIdentifierParts()));
}
SelectorElement GetElement(bool hasTrailingWhitespace)
{
var parentSelector = context.parentSelectorReference();
if (parentSelector != null)
{
return(new ParentReferenceSelectorElement(hasTrailingWhitespace));
}
if (context.pseudoClass() != null)
{
return(new IdentifierSelectorElement(GetPseudoclassIdentifier(), hasTrailingWhitespace));
}
if (context.identifier() != null)
{
return(new IdentifierSelectorElement(GetIdentifier(), hasTrailingWhitespace));
}
var attrib = context.attrib();
if (attrib != null)
{
var identifier = (Identifier)attrib.identifier().Accept(this);
var op = attrib.attribRelate();
if (op != null)
{
return(new AttributeSelectorElement(identifier, op.GetText(), (Expression)attrib.attribValue().Accept(this),
hasTrailingWhitespace));
}
return(new AttributeSelectorElement(identifier, hasTrailingWhitespace));
}
// The lexer rules might match an ID selector as a color, so we account for that here
if (context.HexColor() != null)
{
return(new IdentifierSelectorElement(new Identifier(new ConstantIdentifierPart(context.HexColor().GetText())),
hasTrailingWhitespace));
}
return(new CombinatorSelectorElement(context.combinator().GetText(), hasTrailingWhitespace));
}
bool HasTrailingWhitespace()
{
int index = context.Stop.TokenIndex + 1;
while (index < tokenStream.Size)
{
var tokenType = tokenStream.Get(index).Type;
if (tokenType == LessLexer.WS)
{
return(true);
}
if (tokenType != LessLexer.COMMENT)
{
return(false);
}
index++;
}
return(false);
}
return(GetElement(HasTrailingWhitespace()));
}
private void BuildColorClassifications(ITokenStream tokenStream, ITextSnapshot snapshot)
{
Debug("Start building Classifications at {0}, version {1}", DateTime.Now, snapshot.Version.ToString());
XClassificationSpans newtags;
var regionTags = new List <ClassificationSpan>();
if (tokenStream != null)
{
int iLastInclude = -1;
int iLastPPDefine = -1;
int iLastDefine = -1;
int iLastSLComment = -1;
int iLastDocComment = -1;
int iLastUsing = -1;
newtags = new XClassificationSpans();
keywordContext = null;
for (var iToken = 0; iToken < tokenStream.Size; iToken++)
{
var token = tokenStream.Get(iToken);
// Orphan End ?
if ((keywordContext != null) && (keywordContext.Line != token.Line) && (keywordContext.Type == XSharpLexer.END))
{
newtags.Add(Token2ClassificationSpan(keywordContext, snapshot, xsharpKwCloseType));
keywordContext = null;
}
var span = ClassifyToken(token, regionTags, snapshot);
if (span != null)
{
newtags.Add(span);
// We can have some Open/Close keyword ( FOR..NEXT; WHILE...ENDDO; IF...ENDIF)
if (span.ClassificationType == xsharpKeywordType)
{
span = ClassifyKeyword(token, snapshot);
if (span != null)
{
newtags.Add(span);
}
}
if (!disableRegions)
{
// now look for Regions of similar code lines
switch (token.Type)
{
case XSharpLexer.PP_INCLUDE:
scanForRegion(token, iToken, tokenStream, ref iLastInclude, snapshot, regionTags);
break;
case XSharpLexer.PP_DEFINE:
scanForRegion(token, iToken, tokenStream, ref iLastPPDefine, snapshot, regionTags);
break;
case XSharpLexer.DEFINE:
scanForRegion(token, iToken, tokenStream, ref iLastDefine, snapshot, regionTags);
break;
case XSharpLexer.SL_COMMENT:
scanForRegion(token, iToken, tokenStream, ref iLastSLComment, snapshot, regionTags);
break;
case XSharpLexer.DOC_COMMENT:
scanForRegion(token, iToken, tokenStream, ref iLastDocComment, snapshot, regionTags);
break;
case XSharpLexer.USING:
scanForRegion(token, iToken, tokenStream, ref iLastUsing, snapshot, regionTags);
break;
default:
break;
}
}
}
}
// Orphan End ?
if ((keywordContext != null) && (keywordContext.Type == XSharpLexer.END))
{
newtags.Add(Token2ClassificationSpan(keywordContext, snapshot, xsharpKwCloseType));
keywordContext = null;
}
}
else
{
newtags = _colorTags;
}
System.Diagnostics.Trace.WriteLine("-->> XSharpClassifier.BuildColorClassifications()");
lock (gate)
{
_snapshot = snapshot;
_colorTags = newtags;
_lexerRegions = regionTags;
}
System.Diagnostics.Trace.WriteLine("<<-- XSharpClassifier.BuildColorClassifications()");
Debug("End building Classifications at {0}, version {1}", DateTime.Now, snapshot.Version.ToString());
triggerRepaint(snapshot);
}
public virtual string GetText(string programName, Interval interval)
{
IList <TokenStreamRewriter.RewriteOperation> rewrites;
if (!programs.TryGetValue(programName, out rewrites))
{
rewrites = null;
}
int start = interval.a;
int stop = interval.b;
// ensure start/end are in range
if (stop > tokens.Size - 1)
{
stop = tokens.Size - 1;
}
if (start < 0)
{
start = 0;
}
if (rewrites == null || rewrites.Count == 0)
{
return(tokens.GetText(interval));
}
// no instructions to execute
StringBuilder buf = new StringBuilder();
// First, optimize instruction stream
IDictionary <int, TokenStreamRewriter.RewriteOperation> indexToOp = ReduceToSingleOperationPerIndex(rewrites);
// Walk buffer, executing instructions and emitting tokens
int i = start;
while (i <= stop && i < tokens.Size)
{
TokenStreamRewriter.RewriteOperation op;
if (indexToOp.TryGetValue(i, out op))
{
indexToOp.Remove(i);
}
// remove so any left have index size-1
IToken t = tokens.Get(i);
if (op == null)
{
// no operation at that index, just dump token
if (t.Type != TokenConstants.EOF)
{
buf.Append(t.Text);
}
i++;
}
else
{
// move to next token
i = op.Execute(buf);
}
}
// execute operation and skip
// include stuff after end if it's last index in buffer
// So, if they did an insertAfter(lastValidIndex, "foo"), include
// foo if end==lastValidIndex.
if (stop == tokens.Size - 1)
{
// Scan any remaining operations after last token
// should be included (they will be inserts).
foreach (TokenStreamRewriter.RewriteOperation op in indexToOp.Values)
{
if (op.index >= tokens.Size - 1)
{
buf.Append(op.text);
}
}
}
return(buf.ToString());
}
public static boolean isOpNext(ITokenStream tokens) {
var start = tokens.Index;
var lt = tokens.Get(start);
var stop = getLastOpTokenIndex(tokens);
if (stop == -1) return false;
Console.WriteLine("isOpNext: i={0} t='{1}'", start, lt.getText());
Console.WriteLine(", op='{0}'\n", tokens.GetText(Interval.Of(start, stop)));
return true;
}
/** Find stop token index of next operator; return -1 if not operator. */
public static int getLastOpTokenIndex(ITokenStream tokens) {
var i = tokens.Index; // current on-channel lookahead token index
var lt = tokens.Get(i);
if (lt.getType() == SwiftParser.DOT && tokens.get(i + 1).getType() == SwiftParser.DOT) {
// dot-operator
i += 2; // point at token after ".."
lt = tokens.get(i);
while (lt.getType() != Token.EOF &&
(lt.getType() == SwiftParser.DOT || isOperatorChar(lt.getType()))) {
i++;
lt = tokens.get(i);
}
return i - 1;
}
// Is it regular operator?
if (!isOperatorHead(lt.getType())) {
return -1;
}
i++;
lt = tokens.get(i);
while (lt.getType() != Token.EOF && isOperatorChar(lt.getType())) {
i++;
lt = tokens.get(i);
}
int stop = i - 1;
return stop;
}
protected NoViableAltException NoViableAlt(ITokenStream input,
ParserRuleContext outerContext,
ATNConfigSet configs,
int startIndex)
{
return new NoViableAltException(parser, input,
input.Get(startIndex),
input.LT(1),
configs, outerContext);
}
/// <summary>
/// Converts from a syntax error to a nice exception.
/// </summary>
/// <param name="e">is the syntax error</param>
/// <param name="expression">is the expression text</param>
/// <param name="parser">the parser that parsed the expression</param>
/// <param name="addPleaseCheck">indicates to add "please check" paraphrases</param>
/// <returns>syntax exception</returns>
public static UniformPair <string> Convert(RecognitionException e, string expression, bool addPleaseCheck, EsperEPL2GrammarParser parser)
{
string message;
if (expression.Trim().Length == 0)
{
message = "Unexpected " + END_OF_INPUT_TEXT;
return(new UniformPair <string>(message, expression));
}
IToken t;
IToken tBeforeBefore = null;
IToken tBefore = null;
IToken tAfter = null;
ITokenStream tokenStream = parser.InputStream as ITokenStream;
var tIndex = e.OffendingToken != null ? e.OffendingToken.TokenIndex : int.MaxValue;
if (tIndex < tokenStream.Size)
{
t = tokenStream.Get(tIndex);
if ((tIndex + 1) < tokenStream.Size)
{
tAfter = tokenStream.Get(tIndex + 1);
}
if (tIndex - 1 >= 0)
{
tBefore = tokenStream.Get(tIndex - 1);
}
if (tIndex - 2 >= 0)
{
tBeforeBefore = tokenStream.Get(tIndex - 2);
}
}
else
{
if (tokenStream.Size >= 1)
{
tBeforeBefore = tokenStream.Get(tokenStream.Size - 1);
}
if (tokenStream.Size >= 2)
{
tBefore = tokenStream.Get(tokenStream.Size - 2);
}
t = tokenStream.Get(tokenStream.Size - 1);
}
IToken tEnd = null;
if (tokenStream.Size > 0)
{
tEnd = tokenStream.Get(tokenStream.Size - 1);
}
var positionInfo = GetPositionInfo(t);
var token = t.Type == EsperEPL2GrammarParser.Eof ? "end-of-input" : "'" + t.Text + "'";
var stack = parser.GetParaphrases();
var check = "";
var isSelect = stack.Count == 1 && stack.Peek().Equals("select clause");
if ((stack.Count > 0) && addPleaseCheck)
{
var delimiter = "";
var checkList = new StringBuilder();
checkList.Append(", please check the ");
while (stack.Count != 0)
{
checkList.Append(delimiter);
checkList.Append(stack.Pop());
delimiter = " within the ";
}
check = checkList.ToString();
}
// check if token is a reserved keyword
var keywords = parser.GetKeywords();
var reservedKeyword = false;
if (keywords.Contains(token.ToLower()))
{
token += " (a reserved keyword)";
reservedKeyword = true;
}
else if (tAfter != null && keywords.Contains("'" + tAfter.Text.ToLower() + "'"))
{
token += " ('" + tAfter.Text + "' is a reserved keyword)";
reservedKeyword = true;
}
else
{
if ((tBefore != null) &&
(tAfter != null) &&
(keywords.Contains("'" + tBefore.Text.ToLower() + "'")) &&
(keywords.Contains("'" + tAfter.Text.ToLower() + "'")))
{
token += " ('" + tBefore.Text + "' and '" + tAfter.Text + "' are a reserved keyword)";
reservedKeyword = true;
}
else if ((tBefore != null) &&
(keywords.Contains("'" + tBefore.Text.ToLower() + "'")))
{
token += " ('" + tBefore.Text + "' is a reserved keyword)";
reservedKeyword = true;
}
else if (tEnd != null && keywords.Contains("'" + tEnd.Text.ToLower() + "'"))
{
token += " ('" + tEnd.Text + "' is a reserved keyword)";
reservedKeyword = true;
}
}
// special handling for the select-clause "as" keyword, which is required
if (isSelect && !reservedKeyword)
{
check += GetSelectClauseAsText(tBeforeBefore, t);
}
message = "Incorrect syntax near " + token + positionInfo + check;
if (e is NoViableAltException || e is LexerNoViableAltException || CheckForInputMismatchWithNoExpected(e))
{
var nvaeToken = e.OffendingToken;
var nvaeTokenType = nvaeToken != null ? nvaeToken.Type : EsperEPL2GrammarLexer.Eof;
if (nvaeTokenType == EsperEPL2GrammarLexer.Eof)
{
if (token.Equals(END_OF_INPUT_TEXT))
{
message = "Unexpected " + END_OF_INPUT_TEXT + positionInfo + check;
}
else
{
if (ParseHelper.HasControlCharacters(expression))
{
message = "Unrecognized control characters found in text" + positionInfo;
}
else
{
message = "Unexpected " + END_OF_INPUT_TEXT + " near " + token + positionInfo + check;
}
}
}
else
{
var parserTokenParaphrases = EsperEPL2GrammarParser.GetParserTokenParaphrases();
if (parserTokenParaphrases.Get(nvaeTokenType) != null)
{
message = "Incorrect syntax near " + token + positionInfo + check;
}
else
{
// find next keyword in the next 3 tokens
var currentIndex = tIndex + 1;
while ((currentIndex > 0) &&
(currentIndex < tokenStream.Size - 1) &&
(currentIndex < tIndex + 3))
{
IToken next = tokenStream.Get(currentIndex);
currentIndex++;
var quotedToken = "'" + next.Text + "'";
if (parser.GetKeywords().Contains(quotedToken))
{
check += " near reserved keyword '" + next.Text + "'";
break;
}
}
message = "Incorrect syntax near " + token + positionInfo + check;
}
}
}
else if (e is InputMismatchException)
{
var mismatched = (InputMismatchException)e;
string expected;
var expectedTokens = mismatched.GetExpectedTokens().ToList();
if (expectedTokens.Count > 1)
{
var writer = new StringWriter();
writer.Write("any of the following tokens {");
var delimiter = "";
for (var i = 0; i < expectedTokens.Count; i++)
{
writer.Write(delimiter);
if (i > 5)
{
writer.Write("...");
writer.Write(expectedTokens.Count - 5);
writer.Write(" more");
break;
}
delimiter = ", ";
writer.Write(GetTokenText(parser, expectedTokens[i]));
}
writer.Write("}");
expected = writer.ToString();
}
else
{
expected = GetTokenText(parser, expectedTokens[0]);
}
var offendingTokenType = mismatched.OffendingToken.Type;
var unexpected = GetTokenText(parser, offendingTokenType);
var expecting = " expecting " + expected.Trim() + " but found " + unexpected.Trim();
message = "Incorrect syntax near " + token + expecting + positionInfo + check;
}
return(new UniformPair <string>(message, expression));
}
public static IToken get(this ITokenStream stream, int i)
{
return(stream.Get(i));
}