/// <summary>
/// This constructor is used by the method "generateParseException"
/// in the generated parser. Calling this constructor generates
/// a new object of this type with the fields "currentToken",
/// "expectedTokenSequences", and "tokenImage" set.
/// </summary>
public ParseException(Token currentTokenVal,
int[][] expectedTokenSequencesVal, string[] tokenImageVal)
: base(new MessageImpl(QueryParserMessages.INVALID_SYNTAX, Initialize(
currentTokenVal, expectedTokenSequencesVal, tokenImageVal)))
{
this.currentToken = currentTokenVal;
this.expectedTokenSequences = expectedTokenSequencesVal;
this.tokenImage = tokenImageVal;
}
/// <summary>
/// It uses <paramref name="currentToken"/> and <paramref name="expectedTokenSequences"/> to generate a parse
/// error message and returns it. If this object has been created
/// due to a parse error, and you do not catch it (it gets thrown
/// from the parser) the correct error message
/// gets displayed.
/// </summary>
/// <param name="currentToken"></param>
/// <param name="expectedTokenSequences"></param>
/// <param name="tokenImage"></param>
/// <returns></returns>
private static string Initialize(Token currentToken,
int[][] expectedTokenSequences,
string[] tokenImage)
{
//String eol = System.getProperty("line.separator", "\n");
string eol = Environment.NewLine;
StringBuilder expected = new StringBuilder();
int maxSize = 0;
for (int i = 0; i < expectedTokenSequences.Length; i++)
{
if (maxSize < expectedTokenSequences[i].Length)
{
maxSize = expectedTokenSequences[i].Length;
}
for (int j = 0; j < expectedTokenSequences[i].Length; j++)
{
expected.Append(tokenImage[expectedTokenSequences[i][j]]).Append(' ');
}
if (expectedTokenSequences[i][expectedTokenSequences[i].Length - 1] != 0)
{
expected.Append("...");
}
expected.Append(eol).Append(" ");
}
string retval = "Encountered \"";
Token tok = currentToken.next;
for (int i = 0; i < maxSize; i++)
{
if (i != 0) retval += " ";
if (tok.kind == 0)
{
retval += tokenImage[0];
break;
}
retval += " " + tokenImage[tok.kind];
retval += " \"";
retval += Add_Escapes(tok.image);
retval += " \"";
tok = tok.next;
}
retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;
retval += "." + eol;
if (expectedTokenSequences.Length == 1)
{
retval += "Was expecting:" + eol + " ";
}
else
{
retval += "Was expecting one of:" + eol + " ";
}
retval += expected.ToString();
return retval;
}
private int Jj_ntk()
{
if ((jj_nt = token.next) == null)
return (jj_ntk = (token.next = token_source.GetNextToken()).kind);
else
return (jj_ntk = jj_nt.kind);
}
private void Jj_rescan_token()
{
jj_rescan = true;
for (int i = 0; i < 2; i++)
{
try
{
JJCalls p = jj_2_rtns[i];
do
{
if (p.gen > jj_gen)
{
jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
switch (i)
{
case 0: Jj_3_1(); break;
case 1: Jj_3_2(); break;
}
}
p = p.next;
} while (p != null);
}
#pragma warning disable 168
catch (LookaheadSuccess ls) { }
#pragma warning restore 168
}
jj_rescan = false;
}
private bool Jj_scan_token(int kind)
{
if (jj_scanpos == jj_lastpos)
{
jj_la--;
if (jj_scanpos.next == null)
{
jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.GetNextToken();
}
else
{
jj_lastpos = jj_scanpos = jj_scanpos.next;
}
}
else
{
jj_scanpos = jj_scanpos.next;
}
if (jj_rescan)
{
int i = 0; Token tok = token;
while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
if (tok != null) Jj_add_error_token(kind, i);
}
if (jj_scanpos.kind != kind) return true;
if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
return false;
}
/// <summary>Get the next Token.</summary>
public Token GetNextToken()
{
if (token.next != null) token = token.next;
else token = token.next = token_source.GetNextToken();
jj_ntk = -1;
jj_gen++;
return token;
}
private Token Jj_consume_token(int kind)
{
Token oldToken;
if ((oldToken = token).next != null) token = token.next;
else token = token.next = token_source.GetNextToken();
jj_ntk = -1;
if (token.kind == kind)
{
jj_gen++;
if (++jj_gc > 100)
{
jj_gc = 0;
for (int i = 0; i < jj_2_rtns.Length; i++)
{
JJCalls c = jj_2_rtns[i];
while (c != null)
{
if (c.gen < jj_gen) c.first = null;
c = c.next;
}
}
}
return token;
}
token = oldToken;
jj_kind = kind;
throw GenerateParseException();
}
/// <summary>Reinitialize.</summary>
public void ReInit(StandardSyntaxParserTokenManager tm)
{
token_source = tm;
token = new Token();
jj_ntk = -1;
jj_gen = 0;
for (int i = 0; i < 28; i++) jj_la1[i] = -1;
for (int i = 0; i < jj_2_rtns.Length; i++) jj_2_rtns[i] = new JJCalls();
}
/// <summary>Reinitialize.</summary>
public void ReInit(ICharStream stream)
{
token_source.ReInit(stream);
token = new Token();
jj_ntk = -1;
jj_gen = 0;
for (int i = 0; i < 28; i++) jj_la1[i] = -1;
for (int i = 0; i < jj_2_rtns.Length; i++) jj_2_rtns[i] = new JJCalls();
}
/// <summary>
/// Constructor with user supplied <see cref="ICharStream"/>.
/// </summary>
public StandardSyntaxParser(ICharStream stream)
{
token_source = new StandardSyntaxParserTokenManager(stream);
token = new Token();
jj_ntk = -1;
jj_gen = 0;
for (int i = 0; i < 28; i++) jj_la1[i] = -1;
for (int i = 0; i < jj_2_rtns.Length; i++) jj_2_rtns[i] = new JJCalls();
}
public ParseException(Token currentToken,
int[][] expectedTokenSequences, string[] tokenImage)
: base(string.Format(QueryParserMessages.INVALID_SYNTAX !, Initialize(