private void ParseStart(ParseNode parent) // NonTerminalSymbol: Start
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Start), "Start");
parent.Nodes.Add(node);
// Concat Rule
do { // OneOrMore Rule
ParseAddExpr(node); // NonTerminal Rule: AddExpr
tok = scanner.LookAhead(TokenType.NUMBER, TokenType.BROPEN); // OneOrMore Rule
|| tok.Type == TokenType.NUMBER
|| tok.Type == TokenType.BROPEN); // OneOrMore Rule
// Concat Rule
tok = scanner.Scan(TokenType.EOF); // Terminal Rule: EOF
if (tok.Type != TokenType.EOF)
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOF.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: Start
} // NonTerminalSymbol: Start
private void ParseAddExpr(ParseNode parent) // NonTerminalSymbol: AddExpr
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.AddExpr), "AddExpr");
parent.Nodes.Add(node);
// Concat Rule
ParseMultExpr(node); // NonTerminal Rule: MultExpr
// Concat Rule
tok = scanner.LookAhead(TokenType.PLUSMINUS); // ZeroOrMore Rule
while (tok.Type == TokenType.PLUSMINUS)
{
// Concat Rule
tok = scanner.Scan(TokenType.PLUSMINUS); // Terminal Rule: PLUSMINUS
if (tok.Type != TokenType.PLUSMINUS)
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.PLUSMINUS.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
// Concat Rule
ParseMultExpr(node); // NonTerminal Rule: MultExpr
tok = scanner.LookAhead(); // ZeroOrMore Rule
}
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: AddExpr
private void ParseStart(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Start), "Start");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.COMPLEMENT, TokenType.STATE, TokenType.BROPEN);
if (tok.Type == TokenType.COMPLEMENT
|| tok.Type == TokenType.STATE
|| tok.Type == TokenType.BROPEN)
{
ParseUnionExpr(node);
}
tok = scanner.Scan(TokenType.EOF);
if (tok.Type != TokenType.EOF)
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOF.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
parent.Token.UpdateRange(node.Token);
}
private void ParseStart(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Start), "Start");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.VARIABLE, TokenType.STRING, TokenType.NUMBER, TokenType.BOOLEAN, TokenType.BROPEN);
if (tok.Type == TokenType.VARIABLE
|| tok.Type == TokenType.STRING
|| tok.Type == TokenType.NUMBER
|| tok.Type == TokenType.BOOLEAN
|| tok.Type == TokenType.BROPEN)
{
ParseExpr(node);
}
tok = scanner.Scan(TokenType.EOF);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EOF) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOF.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseSepExpr(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.SepExpr), "SepExpr");
parent.Nodes.Add(node);
ParseOrExpr(node);
tok = scanner.LookAhead(TokenType.SEPARATOR);
while (tok.Type == TokenType.SEPARATOR)
{
tok = scanner.Scan(TokenType.SEPARATOR);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.SEPARATOR) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.SEPARATOR.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
ParseOrExpr(node);
tok = scanner.LookAhead(TokenType.SEPARATOR);
}
parent.Token.UpdateRange(node.Token);
}
private void Parseadd_stmt(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.add_stmt), "add_stmt");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.ADD);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.ADD) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ADD.ToString(), 0x1001, tok));
return;
}
Parseexpr(node);
tok = scanner.Scan(TokenType.EOI);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EOI) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOI.ToString(), 0x1001, tok));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseCompanyMatchedClause(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.CompanyMatchedClause), "CompanyMatchedClause");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.CompanyMatchedKeyword);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.CompanyMatchedKeyword) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.CompanyMatchedKeyword.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
tok = scanner.Scan(TokenType.NUMBER);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.NUMBER) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.NUMBER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseNodeSpec(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.NodeSpec), "NodeSpec");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.IDENTIFIER);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.IDENTIFIER) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.IDENTIFIER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
tok = scanner.Scan(TokenType.IDENTIFIER);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.IDENTIFIER) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.IDENTIFIER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
tok = scanner.Scan(TokenType.IDENTIFIER);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.IDENTIFIER) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.IDENTIFIER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
ParseSuccessors(node);
tok = scanner.LookAhead(TokenType.STRING);
if (tok.Type == TokenType.STRING) {
tok = scanner.Scan(TokenType.STRING);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.STRING) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.STRING.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
}
tok = scanner.Scan(TokenType.SEMICOLON);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.SEMICOLON) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.SEMICOLON.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseArithmeticOperator(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.ArithmeticOperator), "ArithmeticOperator");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.PLUS, TokenType.MINUS, TokenType.ASTERISK, TokenType.FSLASH, TokenType.PERCENT);
switch (tok.Type)
{
case TokenType.PLUS:
tok = scanner.Scan(TokenType.PLUS);
if (tok.Type != TokenType.PLUS)
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.PLUS.ToString(), 0x1001, tok.LinePos, tok.ColumnPos, tok.StartPos, tok.Length));
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.MINUS:
tok = scanner.Scan(TokenType.MINUS);
if (tok.Type != TokenType.MINUS)
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.MINUS.ToString(), 0x1001, tok.LinePos, tok.ColumnPos, tok.StartPos, tok.Length));
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.ASTERISK:
tok = scanner.Scan(TokenType.ASTERISK);
if (tok.Type != TokenType.ASTERISK)
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ASTERISK.ToString(), 0x1001, tok.LinePos, tok.ColumnPos, tok.StartPos, tok.Length));
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.FSLASH:
tok = scanner.Scan(TokenType.FSLASH);
if (tok.Type != TokenType.FSLASH)
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.FSLASH.ToString(), 0x1001, tok.LinePos, tok.ColumnPos, tok.StartPos, tok.Length));
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.PERCENT:
tok = scanner.Scan(TokenType.PERCENT);
if (tok.Type != TokenType.PERCENT)
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.PERCENT.ToString(), 0x1001, tok.LinePos, tok.ColumnPos, tok.StartPos, tok.Length));
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, tok.LinePos, tok.ColumnPos, tok.StartPos, tok.Length));
break;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseExpr(ParseNode parent)
{
//Token tok;
//ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Expr), "Expr");
parent.Nodes.Add(node);
ParseSepExpr(node);
parent.Token.UpdateRange(node.Token);
}
// NonTerminalSymbol: AdditiveExpression
private void ParseAdditiveExpression(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.AdditiveExpression), "AdditiveExpression");
parent.Nodes.Add(node);
// Concat Rule
ParseMultiplicativeExpression(node); // NonTerminal Rule: MultiplicativeExpression
// Concat Rule
tok = scanner.LookAhead(TokenType.PLUS, TokenType.MINUS); // ZeroOrMore Rule
while (tok.Type == TokenType.PLUS
|| tok.Type == TokenType.MINUS)
{
// Concat Rule
tok = scanner.LookAhead(TokenType.PLUS, TokenType.MINUS); // Choice Rule
switch (tok.Type)
{ // Choice Rule
case TokenType.PLUS:
tok = scanner.Scan(TokenType.PLUS); // Terminal Rule: PLUS
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.PLUS)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.PLUS.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.MINUS:
tok = scanner.Scan(TokenType.MINUS); // Terminal Rule: MINUS
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.MINUS)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.MINUS.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
} // Choice Rule
// Concat Rule
ParseMultiplicativeExpression(node); // NonTerminal Rule: MultiplicativeExpression
tok = scanner.LookAhead(TokenType.PLUS, TokenType.MINUS); // ZeroOrMore Rule
}
parent.Token.UpdateRange(node.Token);
}
private void ParseStart(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Start), "Start");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.Code, TokenType.Technique, TokenType.Sampler);
while (tok.Type == TokenType.Code
|| tok.Type == TokenType.Technique
|| tok.Type == TokenType.Sampler)
{
tok = scanner.LookAhead(TokenType.Code, TokenType.Technique, TokenType.Sampler);
switch (tok.Type)
{
case TokenType.Code:
tok = scanner.Scan(TokenType.Code);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.Code) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.Code.ToString(), 0x1001, tok));
return;
}
break;
case TokenType.Technique:
ParseTechnique_Declaration(node);
break;
case TokenType.Sampler:
ParseSampler_Declaration(node);
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, tok));
break;
}
tok = scanner.LookAhead(TokenType.Code, TokenType.Technique, TokenType.Sampler);
}
tok = scanner.Scan(TokenType.EndOfFile);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EndOfFile) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EndOfFile.ToString(), 0x1001, tok));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseStart(ParseNode parent) // NonTerminalSymbol: Start
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Start), "Start");
parent.Nodes.Add(node);
// Concat Rule
tok = scanner.LookAhead(TokenType.Code, TokenType.Technique, TokenType.Sampler); // ZeroOrMore Rule
while (tok.Type == TokenType.Code
|| tok.Type == TokenType.Technique
|| tok.Type == TokenType.Sampler)
{
tok = scanner.LookAhead(TokenType.Code, TokenType.Technique, TokenType.Sampler); // Choice Rule
switch (tok.Type)
{ // Choice Rule
case TokenType.Code:
tok = scanner.Scan(TokenType.Code); // Terminal Rule: Code
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.Code) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.Code.ToString(), 0x1001, tok));
return;
}
break;
case TokenType.Technique:
ParseTechnique_Declaration(node); // NonTerminal Rule: Technique_Declaration
break;
case TokenType.Sampler:
ParseSampler_Declaration(node); // NonTerminal Rule: Sampler_Declaration
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected Code, Technique, or Sampler.", 0x0002, tok));
break;
} // Choice Rule
tok = scanner.LookAhead(TokenType.Code, TokenType.Technique, TokenType.Sampler); // ZeroOrMore Rule
}
// Concat Rule
tok = scanner.Scan(TokenType.EndOfFile); // Terminal Rule: EndOfFile
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EndOfFile) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EndOfFile.ToString(), 0x1001, tok));
return;
}
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: Start
private void ParseExpression(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Expression), "Expression");
parent.Nodes.Add(node);
ParseConditionalExpression(node);
parent.Token.UpdateRange(node.Token);
}
private void ParseAddExpr(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.AddExpr), "AddExpr");
parent.Nodes.Add(node);
ParseMultExpr(node);
tok = scanner.LookAhead(TokenType.PLUS, TokenType.MINUS);
while (tok.Type == TokenType.PLUS
|| tok.Type == TokenType.MINUS)
{
tok = scanner.LookAhead(TokenType.PLUS, TokenType.MINUS);
switch (tok.Type)
{
case TokenType.PLUS:
tok = scanner.Scan(TokenType.PLUS);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.PLUS)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.PLUS.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.MINUS:
tok = scanner.Scan(TokenType.MINUS);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.MINUS)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.MINUS.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
}
ParseMultExpr(node);
tok = scanner.LookAhead(TokenType.PLUS, TokenType.MINUS);
}
parent.Token.UpdateRange(node.Token);
}
} // NonTerminalSymbol: Start
private void ParseExpression(ParseNode parent) // NonTerminalSymbol: Expression
{
ParseNode node = parent.CreateNode(_scanner.GetToken(TokenType.Expression), "Expression");
parent.Nodes.Add(node);
// Concat Rule
ParseLogicalOr(node); // NonTerminal Rule: LogicalOr
// Concat Rule
var tok = _scanner.LookAhead(TokenType.QUESTION);
if (tok.Type == TokenType.QUESTION)
{
// Concat Rule
tok = _scanner.Scan(TokenType.QUESTION); // Terminal Rule: QUESTION
var n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.QUESTION)
{
tree.Errors.Add(new ParseError(
"Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.QUESTION.ToString(), 0x1001, tok));
return;
}
// Concat Rule
ParseExpression(node); // NonTerminal Rule: Expression
// Concat Rule
tok = _scanner.Scan(TokenType.COLON); // Terminal Rule: COLON
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.COLON)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.COLON.ToString(),
0x1001, tok));
return;
}
// Concat Rule
ParseExpression(node); // NonTerminal Rule: Expression
}
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: Expression
private void ParseBODY(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.BODY), "BODY");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.IF, TokenType.DEFINITION, TokenType.PLUSMINUS, TokenType.MULTDIV, TokenType.LAMBDAPREFIX, TokenType.BROPEN);
switch (tok.Type)
{
case TokenType.IF:
case TokenType.DEFINITION:
case TokenType.PLUSMINUS:
case TokenType.MULTDIV:
case TokenType.LAMBDAPREFIX:
ParsePARAM(node);
break;
case TokenType.BROPEN:
tok = scanner.Scan(TokenType.BROPEN);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.BROPEN) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BROPEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
ParsePARAM(node);
tok = scanner.Scan(TokenType.BRCLOSE);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.BRCLOSE) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRCLOSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseInteger(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Integer), "Integer");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.INTEGER);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.INTEGER) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.INTEGER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseAtom(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Atom), "Atom");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.NUMBER, TokenType.BROPEN);
switch (tok.Type)
{
case TokenType.NUMBER:
tok = scanner.Scan(TokenType.NUMBER);
if (tok.Type != TokenType.NUMBER)
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.NUMBER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.BROPEN:
tok = scanner.Scan(TokenType.BROPEN);
if (tok.Type != TokenType.BROPEN)
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BROPEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
ParseAddExpr(node);
tok = scanner.Scan(TokenType.BRCLOSE);
if (tok.Type != TokenType.BRCLOSE)
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRCLOSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
}
parent.Token.UpdateRange(node.Token);
}
} // NonTerminalSymbol: RealLiteral
private void ParseStringLiteral(ParseNode parent) // NonTerminalSymbol: StringLiteral
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.StringLiteral), "StringLiteral");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.STRINGLITERAL); // Terminal Rule: STRINGLITERAL
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.STRINGLITERAL)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.STRINGLITERAL.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: StringLiteral
} // NonTerminalSymbol: StringLiteral
private void ParseVariable(ParseNode parent) // NonTerminalSymbol: Variable
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Variable), "Variable");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.VARIABLE); // Terminal Rule: VARIABLE
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.VARIABLE)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.VARIABLE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: Variable
private void ParseBlock(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Block), "Block");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.MIDDLEOPEN);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.MIDDLEOPEN)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.MIDDLEOPEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
tok = scanner.LookAhead(TokenType.IDENTIFIER);
while (tok.Type == TokenType.IDENTIFIER)
{
ParseStatementList(node);
tok = scanner.LookAhead(TokenType.IDENTIFIER);
}
tok = scanner.Scan(TokenType.MIDDLECLOSE);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.MIDDLECLOSE)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.MIDDLECLOSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseInteger(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Integer), "Integer");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.INTEGER);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.INTEGER)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.INTEGER.ToString(), 0x1001,
0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseStart(ParseNode parent) // NonTerminalSymbol: Start
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Start), "Start");
parent.Nodes.Add(node);
// Concat Rule
tok = scanner.LookAhead(TokenType.FUNCTION, TokenType.VARIABLE, TokenType.BOOLEANLITERAL, TokenType.DECIMALINTEGERLITERAL, TokenType.HEXINTEGERLITERAL, TokenType.REALLITERAL, TokenType.STRINGLITERAL, TokenType.BRACKETOPEN, TokenType.PLUS, TokenType.MINUS, TokenType.NOT, TokenType.ASSIGN); // Option Rule
if (tok.Type == TokenType.FUNCTION ||
tok.Type == TokenType.VARIABLE ||
tok.Type == TokenType.BOOLEANLITERAL ||
tok.Type == TokenType.DECIMALINTEGERLITERAL ||
tok.Type == TokenType.HEXINTEGERLITERAL ||
tok.Type == TokenType.REALLITERAL ||
tok.Type == TokenType.STRINGLITERAL ||
tok.Type == TokenType.BRACKETOPEN ||
tok.Type == TokenType.PLUS ||
tok.Type == TokenType.MINUS ||
tok.Type == TokenType.NOT ||
tok.Type == TokenType.ASSIGN)
{
ParseExpression(node); // NonTerminal Rule: Expression
}
// Concat Rule
tok = scanner.Scan(TokenType.EOF); // Terminal Rule: EOF
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EOF)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOF.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: Start
private void ParseStart(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Start), "Start");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.NOT, TokenType.MINUS, TokenType.STRING, TokenType.DECIMAL, TokenType.INTEGER, TokenType.TRUE, TokenType.FALSE, TokenType.NULL, TokenType.INTRANGE, TokenType.LBRACKET, TokenType.LBRACE, TokenType.IDENTIFIER, TokenType.LPAREN, TokenType.FUNCTION);
if (tok.Type == TokenType.NOT
|| tok.Type == TokenType.MINUS
|| tok.Type == TokenType.STRING
|| tok.Type == TokenType.DECIMAL
|| tok.Type == TokenType.INTEGER
|| tok.Type == TokenType.TRUE
|| tok.Type == TokenType.FALSE
|| tok.Type == TokenType.NULL
|| tok.Type == TokenType.INTRANGE
|| tok.Type == TokenType.LBRACKET
|| tok.Type == TokenType.LBRACE
|| tok.Type == TokenType.IDENTIFIER
|| tok.Type == TokenType.LPAREN
|| tok.Type == TokenType.FUNCTION)
{
ParseExpression(node);
}
tok = scanner.Scan(TokenType.EOF);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EOF) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOF.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseStart(ParseNode parent) // NonTerminalSymbol: Start
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Start), "Start");
parent.Nodes.Add(node);
// Concat Rule
tok = scanner.LookAhead(TokenType.ANY_TEXT, TokenType.ANY_SYMBOL, TokenType.IdKeyword1, TokenType.IdKeyword2, TokenType.TimeKeyword, TokenType.CommentKeyword1, TokenType.CommentKeyword2, TokenType.CommentKeyword3, TokenType.CommentKeyword4, TokenType.StatusKeyword1, TokenType.StatusKeyword2); // ZeroOrMore Rule
while (tok.Type == TokenType.ANY_TEXT
|| tok.Type == TokenType.ANY_SYMBOL
|| tok.Type == TokenType.IdKeyword1
|| tok.Type == TokenType.IdKeyword2
|| tok.Type == TokenType.TimeKeyword
|| tok.Type == TokenType.CommentKeyword1
|| tok.Type == TokenType.CommentKeyword2
|| tok.Type == TokenType.CommentKeyword3
|| tok.Type == TokenType.CommentKeyword4
|| tok.Type == TokenType.StatusKeyword1
|| tok.Type == TokenType.StatusKeyword2)
{
ParseActionNode(node); // NonTerminal Rule: ActionNode
tok = scanner.LookAhead(TokenType.ANY_TEXT, TokenType.ANY_SYMBOL, TokenType.IdKeyword1, TokenType.IdKeyword2, TokenType.TimeKeyword, TokenType.CommentKeyword1, TokenType.CommentKeyword2, TokenType.CommentKeyword3, TokenType.CommentKeyword4, TokenType.StatusKeyword1, TokenType.StatusKeyword2); // ZeroOrMore Rule
}
// Concat Rule
tok = scanner.Scan(TokenType.EOF); // Terminal Rule: EOF
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EOF) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOF.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: Start
} // NonTerminalSymbol: Function
private void ParsePrimaryExpression(ParseNode parent) // NonTerminalSymbol: PrimaryExpression
{
Token tok;
//ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.PrimaryExpression), "PrimaryExpression");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.FUNCTION, TokenType.VARIABLE, TokenType.BOOLEANLITERAL, TokenType.DECIMALINTEGERLITERAL, TokenType.HEXINTEGERLITERAL, TokenType.REALLITERAL, TokenType.STRINGLITERAL, TokenType.BRACKETOPEN); // Choice Rule
switch (tok.Type)
{ // Choice Rule
case TokenType.FUNCTION:
ParseFunction(node); // NonTerminal Rule: Function
break;
case TokenType.VARIABLE:
ParseVariable(node); // NonTerminal Rule: Variable
break;
case TokenType.BOOLEANLITERAL:
case TokenType.DECIMALINTEGERLITERAL:
case TokenType.HEXINTEGERLITERAL:
case TokenType.REALLITERAL:
case TokenType.STRINGLITERAL:
ParseLiteral(node); // NonTerminal Rule: Literal
break;
case TokenType.BRACKETOPEN:
ParseParenthesizedExpression(node); // NonTerminal Rule: ParenthesizedExpression
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
} // Choice Rule
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: PrimaryExpression
private void ParseCqlCommand(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.CqlCommand), "CqlCommand");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.EVERYTHING_BUT_START_WITH_BANG);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EVERYTHING_BUT_START_WITH_BANG)
{
tree.Errors.Add(
new ParseError(
"Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EVERYTHING_BUT_START_WITH_BANG.ToString(),
0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseStart(ParseNode parent) // NonTerminalSymbol: Start
{
ParseNode node = parent.CreateNode(_scanner.GetToken(TokenType.Start), "Start");
parent.Nodes.Add(node);
// Concat Rule
ParseExpression(node); // NonTerminal Rule: Expression
// Concat Rule
var tok = _scanner.Scan(TokenType.EOF);
var n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EOF)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOF.ToString(),
0x1001, tok));
return;
}
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: Start
private void ParseCombineOperator(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.CombineOperator), "CombineOperator");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.AND, TokenType.OR);
switch (tok.Type)
{
case TokenType.AND:
tok = scanner.Scan(TokenType.AND);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.AND) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.AND.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.OR:
tok = scanner.Scan(TokenType.OR);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.OR) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.OR.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseStart(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Start), "Start");
parent.Nodes.Add(node);
ParseComplexExpr(node);
tok = scanner.Scan(TokenType.EOF);
if (tok.Type != TokenType.EOF)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOF.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
parent.Token.UpdateRange(node.Token);
}
} // NonTerminalSymbol: PrimaryExpression
private void ParseParenthesizedExpression(ParseNode parent) // NonTerminalSymbol: ParenthesizedExpression
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.ParenthesizedExpression), "ParenthesizedExpression");
parent.Nodes.Add(node);
// Concat Rule
tok = scanner.Scan(TokenType.BRACKETOPEN); // Terminal Rule: BRACKETOPEN
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.BRACKETOPEN)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRACKETOPEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
// Concat Rule
ParseExpression(node); // NonTerminal Rule: Expression
// Concat Rule
tok = scanner.Scan(TokenType.BRACKETCLOSE); // Terminal Rule: BRACKETCLOSE
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.BRACKETCLOSE)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRACKETCLOSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: ParenthesizedExpression
private void ParseParams(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Params), "Params");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.BRACKETOPEN);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.BRACKETOPEN)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRACKETOPEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
ParseParam(node);
tok = scanner.Scan(TokenType.BRACKETCLOSE);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.BRACKETCLOSE)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRACKETCLOSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseClause(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Clause), "Clause");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.TERM, TokenType.QUOTE, TokenType.BROPEN);
switch (tok.Type)
{
case TokenType.TERM:
case TokenType.QUOTE:
ParseTerm(node);
break;
case TokenType.BROPEN:
ParseSubClause(node);
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseAtom(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Atom), "Atom");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.VARIABLE, TokenType.STRING, TokenType.NUMBER, TokenType.BOOLEAN, TokenType.BROPEN);
switch (tok.Type)
{
case TokenType.VARIABLE:
tok = scanner.Scan(TokenType.VARIABLE);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.VARIABLE)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.VARIABLE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.STRING:
tok = scanner.Scan(TokenType.STRING);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.STRING)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.STRING.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.NUMBER:
tok = scanner.Scan(TokenType.NUMBER);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.NUMBER)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.NUMBER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.BOOLEAN:
tok = scanner.Scan(TokenType.BOOLEAN);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.BOOLEAN)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BOOLEAN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.BROPEN:
tok = scanner.Scan(TokenType.BROPEN);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.BROPEN)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BROPEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
ParseExpr(node);
tok = scanner.Scan(TokenType.BRCLOSE);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.BRCLOSE)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRCLOSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
}
parent.Token.UpdateRange(node.Token);
}
private void Parseonoff_trailer(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.onoff_trailer), "onoff_trailer");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.ON, TokenType.OFF);
switch (tok.Type)
{
case TokenType.ON:
tok = scanner.Scan(TokenType.ON);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.ON) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ON.ToString(), 0x1001, tok));
return;
}
break;
case TokenType.OFF:
tok = scanner.Scan(TokenType.OFF);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.OFF) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.OFF.ToString(), 0x1001, tok));
return;
}
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, tok));
break;
}
parent.Token.UpdateRange(node.Token);
}
private void ParseCompExpr(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.CompExpr), "CompExpr");
parent.Nodes.Add(node);
ParseAddExpr(node);
tok = scanner.LookAhead(TokenType.EQUAL, TokenType.NOTEQUAL, TokenType.SMALLEQ, TokenType.GREATEQ, TokenType.SMALLTH, TokenType.GREATTH);
if (tok.Type == TokenType.EQUAL ||
tok.Type == TokenType.NOTEQUAL ||
tok.Type == TokenType.SMALLEQ ||
tok.Type == TokenType.GREATEQ ||
tok.Type == TokenType.SMALLTH ||
tok.Type == TokenType.GREATTH)
{
tok = scanner.LookAhead(TokenType.EQUAL, TokenType.NOTEQUAL, TokenType.SMALLEQ, TokenType.GREATEQ, TokenType.SMALLTH, TokenType.GREATTH);
switch (tok.Type)
{
case TokenType.EQUAL:
tok = scanner.Scan(TokenType.EQUAL);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EQUAL)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EQUAL.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.NOTEQUAL:
tok = scanner.Scan(TokenType.NOTEQUAL);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.NOTEQUAL)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.NOTEQUAL.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.SMALLEQ:
tok = scanner.Scan(TokenType.SMALLEQ);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.SMALLEQ)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.SMALLEQ.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.GREATEQ:
tok = scanner.Scan(TokenType.GREATEQ);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.GREATEQ)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.GREATEQ.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.SMALLTH:
tok = scanner.Scan(TokenType.SMALLTH);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.SMALLTH)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.SMALLTH.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.GREATTH:
tok = scanner.Scan(TokenType.GREATTH);
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.GREATTH)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.GREATTH.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
}
ParseAddExpr(node);
}
parent.Token.UpdateRange(node.Token);
}
private void Parseprint_stmt(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.print_stmt), "print_stmt");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.PRINT);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.PRINT) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.PRINT.ToString(), 0x1001, tok));
return;
}
Parseexpr(node);
tok = scanner.LookAhead(TokenType.AT);
if (tok.Type == TokenType.AT)
{
tok = scanner.Scan(TokenType.AT);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.AT) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.AT.ToString(), 0x1001, tok));
return;
}
tok = scanner.Scan(TokenType.BRACKETOPEN);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.BRACKETOPEN) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRACKETOPEN.ToString(), 0x1001, tok));
return;
}
Parseexpr(node);
tok = scanner.Scan(TokenType.COMMA);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.COMMA) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.COMMA.ToString(), 0x1001, tok));
return;
}
Parseexpr(node);
tok = scanner.Scan(TokenType.BRACKETCLOSE);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.BRACKETCLOSE) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BRACKETCLOSE.ToString(), 0x1001, tok));
return;
}
}
tok = scanner.Scan(TokenType.EOI);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EOI) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOI.ToString(), 0x1001, tok));
return;
}
parent.Token.UpdateRange(node.Token);
}
private void Parseon_stmt(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.on_stmt), "on_stmt");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.ON);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.ON) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ON.ToString(), 0x1001, tok));
return;
}
Parsevaridentifier(node);
Parseinstruction(node);
tok = scanner.LookAhead(TokenType.EOI);
if (tok.Type == TokenType.EOI)
{
tok = scanner.Scan(TokenType.EOI);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EOI) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOI.ToString(), 0x1001, tok));
return;
}
}
parent.Token.UpdateRange(node.Token);
}
private void Parsefromloop_stmt(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.fromloop_stmt), "fromloop_stmt");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.FROM);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.FROM) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.FROM.ToString(), 0x1001, tok));
return;
}
Parseinstruction_block(node);
tok = scanner.Scan(TokenType.UNTIL);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.UNTIL) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.UNTIL.ToString(), 0x1001, tok));
return;
}
Parseexpr(node);
tok = scanner.Scan(TokenType.STEP);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.STEP) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.STEP.ToString(), 0x1001, tok));
return;
}
Parseinstruction_block(node);
tok = scanner.Scan(TokenType.DO);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.DO) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.DO.ToString(), 0x1001, tok));
return;
}
Parseinstruction(node);
tok = scanner.LookAhead(TokenType.EOI);
if (tok.Type == TokenType.EOI)
{
tok = scanner.Scan(TokenType.EOI);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EOI) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOI.ToString(), 0x1001, tok));
return;
}
}
parent.Token.UpdateRange(node.Token);
}
private void Parseunlock_stmt(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.unlock_stmt), "unlock_stmt");
parent.Nodes.Add(node);
tok = scanner.Scan(TokenType.UNLOCK);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.UNLOCK) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.UNLOCK.ToString(), 0x1001, tok));
return;
}
tok = scanner.LookAhead(TokenType.IDENTIFIER, TokenType.ALL);
switch (tok.Type)
{
case TokenType.IDENTIFIER:
tok = scanner.Scan(TokenType.IDENTIFIER);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.IDENTIFIER) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.IDENTIFIER.ToString(), 0x1001, tok));
return;
}
break;
case TokenType.ALL:
tok = scanner.Scan(TokenType.ALL);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.ALL) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ALL.ToString(), 0x1001, tok));
return;
}
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, tok));
break;
}
tok = scanner.Scan(TokenType.EOI);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EOI) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOI.ToString(), 0x1001, tok));
return;
}
parent.Token.UpdateRange(node.Token);
}
} // NonTerminalSymbol: ParenthesizedExpression
private void ParseUnaryExpression(ParseNode parent) // NonTerminalSymbol: UnaryExpression
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.UnaryExpression), "UnaryExpression");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.FUNCTION, TokenType.VARIABLE, TokenType.BOOLEANLITERAL, TokenType.DECIMALINTEGERLITERAL, TokenType.HEXINTEGERLITERAL, TokenType.REALLITERAL, TokenType.STRINGLITERAL, TokenType.BRACKETOPEN, TokenType.PLUS, TokenType.MINUS, TokenType.NOT); // Choice Rule
switch (tok.Type)
{ // Choice Rule
case TokenType.FUNCTION:
case TokenType.VARIABLE:
case TokenType.BOOLEANLITERAL:
case TokenType.DECIMALINTEGERLITERAL:
case TokenType.HEXINTEGERLITERAL:
case TokenType.REALLITERAL:
case TokenType.STRINGLITERAL:
case TokenType.BRACKETOPEN:
ParsePrimaryExpression(node); // NonTerminal Rule: PrimaryExpression
break;
case TokenType.PLUS:
// Concat Rule
tok = scanner.Scan(TokenType.PLUS); // Terminal Rule: PLUS
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.PLUS)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.PLUS.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
// Concat Rule
ParseUnaryExpression(node); // NonTerminal Rule: UnaryExpression
break;
case TokenType.MINUS:
// Concat Rule
tok = scanner.Scan(TokenType.MINUS); // Terminal Rule: MINUS
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.MINUS)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.MINUS.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
// Concat Rule
ParseUnaryExpression(node); // NonTerminal Rule: UnaryExpression
break;
case TokenType.NOT:
// Concat Rule
tok = scanner.Scan(TokenType.NOT); // Terminal Rule: NOT
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.NOT)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.NOT.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
// Concat Rule
ParseUnaryExpression(node); // NonTerminal Rule: UnaryExpression
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
} // Choice Rule
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: UnaryExpression
private void ParseStart(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Start), "Start");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.SET, TokenType.IF, TokenType.UNTIL, TokenType.FROM, TokenType.UNLOCK, TokenType.PRINT, TokenType.ON, TokenType.TOGGLE, TokenType.WAIT, TokenType.WHEN, TokenType.STAGE, TokenType.CLEARSCREEN, TokenType.ADD, TokenType.REMOVE, TokenType.LOG, TokenType.BREAK, TokenType.PRESERVE, TokenType.PARAMETER, TokenType.FUNCTION, TokenType.LOCK, TokenType.DECLARE, TokenType.LOCAL, TokenType.GLOBAL, TokenType.RETURN, TokenType.SWITCH, TokenType.COPY, TokenType.RENAME, TokenType.DELETE, TokenType.EDIT, TokenType.RUN, TokenType.COMPILE, TokenType.LIST, TokenType.REBOOT, TokenType.SHUTDOWN, TokenType.FOR, TokenType.UNSET, TokenType.CURLYOPEN, TokenType.INTEGER, TokenType.DOUBLE, TokenType.TRUEFALSE, TokenType.IDENTIFIER, TokenType.FILEIDENT, TokenType.BRACKETOPEN, TokenType.STRING, TokenType.ATSIGN);
while (tok.Type == TokenType.SET
|| tok.Type == TokenType.IF
|| tok.Type == TokenType.UNTIL
|| tok.Type == TokenType.FROM
|| tok.Type == TokenType.UNLOCK
|| tok.Type == TokenType.PRINT
|| tok.Type == TokenType.ON
|| tok.Type == TokenType.TOGGLE
|| tok.Type == TokenType.WAIT
|| tok.Type == TokenType.WHEN
|| tok.Type == TokenType.STAGE
|| tok.Type == TokenType.CLEARSCREEN
|| tok.Type == TokenType.ADD
|| tok.Type == TokenType.REMOVE
|| tok.Type == TokenType.LOG
|| tok.Type == TokenType.BREAK
|| tok.Type == TokenType.PRESERVE
|| tok.Type == TokenType.PARAMETER
|| tok.Type == TokenType.FUNCTION
|| tok.Type == TokenType.LOCK
|| tok.Type == TokenType.DECLARE
|| tok.Type == TokenType.LOCAL
|| tok.Type == TokenType.GLOBAL
|| tok.Type == TokenType.RETURN
|| tok.Type == TokenType.SWITCH
|| tok.Type == TokenType.COPY
|| tok.Type == TokenType.RENAME
|| tok.Type == TokenType.DELETE
|| tok.Type == TokenType.EDIT
|| tok.Type == TokenType.RUN
|| tok.Type == TokenType.COMPILE
|| tok.Type == TokenType.LIST
|| tok.Type == TokenType.REBOOT
|| tok.Type == TokenType.SHUTDOWN
|| tok.Type == TokenType.FOR
|| tok.Type == TokenType.UNSET
|| tok.Type == TokenType.CURLYOPEN
|| tok.Type == TokenType.INTEGER
|| tok.Type == TokenType.DOUBLE
|| tok.Type == TokenType.TRUEFALSE
|| tok.Type == TokenType.IDENTIFIER
|| tok.Type == TokenType.FILEIDENT
|| tok.Type == TokenType.BRACKETOPEN
|| tok.Type == TokenType.STRING
|| tok.Type == TokenType.ATSIGN)
{
Parseinstruction(node);
tok = scanner.LookAhead(TokenType.SET, TokenType.IF, TokenType.UNTIL, TokenType.FROM, TokenType.UNLOCK, TokenType.PRINT, TokenType.ON, TokenType.TOGGLE, TokenType.WAIT, TokenType.WHEN, TokenType.STAGE, TokenType.CLEARSCREEN, TokenType.ADD, TokenType.REMOVE, TokenType.LOG, TokenType.BREAK, TokenType.PRESERVE, TokenType.PARAMETER, TokenType.FUNCTION, TokenType.LOCK, TokenType.DECLARE, TokenType.LOCAL, TokenType.GLOBAL, TokenType.RETURN, TokenType.SWITCH, TokenType.COPY, TokenType.RENAME, TokenType.DELETE, TokenType.EDIT, TokenType.RUN, TokenType.COMPILE, TokenType.LIST, TokenType.REBOOT, TokenType.SHUTDOWN, TokenType.FOR, TokenType.UNSET, TokenType.CURLYOPEN, TokenType.INTEGER, TokenType.DOUBLE, TokenType.TRUEFALSE, TokenType.IDENTIFIER, TokenType.FILEIDENT, TokenType.BRACKETOPEN, TokenType.STRING, TokenType.ATSIGN);
}
tok = scanner.Scan(TokenType.EOF);
n = node.CreateNode(tok, tok.ToString() );
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.EOF) {
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.EOF.ToString(), 0x1001, tok));
return;
}
parent.Token.UpdateRange(node.Token);
}
} // NonTerminalSymbol: PowerExpression
private void ParseMultiplicativeExpression(ParseNode parent) // NonTerminalSymbol: MultiplicativeExpression
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.MultiplicativeExpression), "MultiplicativeExpression");
parent.Nodes.Add(node);
// Concat Rule
ParsePowerExpression(node); // NonTerminal Rule: PowerExpression
// Concat Rule
tok = scanner.LookAhead(TokenType.ASTERIKS, TokenType.SLASH, TokenType.PERCENT); // ZeroOrMore Rule
while (tok.Type == TokenType.ASTERIKS ||
tok.Type == TokenType.SLASH ||
tok.Type == TokenType.PERCENT)
{
// Concat Rule
tok = scanner.LookAhead(TokenType.ASTERIKS, TokenType.SLASH, TokenType.PERCENT); // Choice Rule
switch (tok.Type)
{ // Choice Rule
case TokenType.ASTERIKS:
tok = scanner.Scan(TokenType.ASTERIKS); // Terminal Rule: ASTERIKS
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.ASTERIKS)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ASTERIKS.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.SLASH:
tok = scanner.Scan(TokenType.SLASH); // Terminal Rule: SLASH
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.SLASH)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.SLASH.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.PERCENT:
tok = scanner.Scan(TokenType.PERCENT); // Terminal Rule: PERCENT
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.PERCENT)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.PERCENT.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
} // Choice Rule
// Concat Rule
ParsePowerExpression(node); // NonTerminal Rule: PowerExpression
tok = scanner.LookAhead(TokenType.ASTERIKS, TokenType.SLASH, TokenType.PERCENT); // ZeroOrMore Rule
}
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: MultiplicativeExpression
} // NonTerminalSymbol: ConcatEpression
private void ParseRelationalExpression(ParseNode parent) // NonTerminalSymbol: RelationalExpression
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.RelationalExpression), "RelationalExpression");
parent.Nodes.Add(node);
// Concat Rule
ParseConcatEpression(node); // NonTerminal Rule: ConcatEpression
// Concat Rule
tok = scanner.LookAhead(TokenType.LESSTHAN, TokenType.LESSEQUAL, TokenType.GREATERTHAN, TokenType.GREATEREQUAL); // Option Rule
if (tok.Type == TokenType.LESSTHAN ||
tok.Type == TokenType.LESSEQUAL ||
tok.Type == TokenType.GREATERTHAN ||
tok.Type == TokenType.GREATEREQUAL)
{
// Concat Rule
tok = scanner.LookAhead(TokenType.LESSTHAN, TokenType.LESSEQUAL, TokenType.GREATERTHAN, TokenType.GREATEREQUAL); // Choice Rule
switch (tok.Type)
{ // Choice Rule
case TokenType.LESSTHAN:
tok = scanner.Scan(TokenType.LESSTHAN); // Terminal Rule: LESSTHAN
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.LESSTHAN)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.LESSTHAN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.LESSEQUAL:
tok = scanner.Scan(TokenType.LESSEQUAL); // Terminal Rule: LESSEQUAL
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.LESSEQUAL)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.LESSEQUAL.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.GREATERTHAN:
tok = scanner.Scan(TokenType.GREATERTHAN); // Terminal Rule: GREATERTHAN
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.GREATERTHAN)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.GREATERTHAN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
case TokenType.GREATEREQUAL:
tok = scanner.Scan(TokenType.GREATEREQUAL); // Terminal Rule: GREATEREQUAL
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
if (tok.Type != TokenType.GREATEREQUAL)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.GREATEREQUAL.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
return;
}
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
} // Choice Rule
// Concat Rule
ParseConcatEpression(node); // NonTerminal Rule: ConcatEpression
}
parent.Token.UpdateRange(node.Token);
} // NonTerminalSymbol: RelationalExpression
private void ParseArrayElems(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.ArrayElems), "ArrayElems");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.NULL, TokenType.BOOL, TokenType.NUMBER, TokenType.STRING, TokenType.PARENOPEN, TokenType.BRACEOPEN, TokenType.SHEETNAME, TokenType.ADDRESS, TokenType.ERR, TokenType.FUNC);
if (tok.Type == TokenType.NULL ||
tok.Type == TokenType.BOOL ||
tok.Type == TokenType.NUMBER ||
tok.Type == TokenType.STRING ||
tok.Type == TokenType.PARENOPEN ||
tok.Type == TokenType.BRACEOPEN ||
tok.Type == TokenType.SHEETNAME ||
tok.Type == TokenType.ADDRESS ||
tok.Type == TokenType.ERR ||
tok.Type == TokenType.FUNC)
{
ParseComplexExpr(node);
}
tok = scanner.LookAhead(TokenType.COMMA, TokenType.SEMICOLON);
while (tok.Type == TokenType.COMMA ||
tok.Type == TokenType.SEMICOLON)
{
tok = scanner.LookAhead(TokenType.COMMA, TokenType.SEMICOLON);
switch (tok.Type)
{
case TokenType.COMMA:
tok = scanner.Scan(TokenType.COMMA);
if (tok.Type != TokenType.COMMA)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.COMMA.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.SEMICOLON:
tok = scanner.Scan(TokenType.SEMICOLON);
if (tok.Type != TokenType.SEMICOLON)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.SEMICOLON.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
}
ParseComplexExpr(node);
tok = scanner.LookAhead(TokenType.COMMA, TokenType.SEMICOLON);
}
parent.Token.UpdateRange(node.Token);
}
private void ParseRange(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Range), "Range");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.SHEETNAME);
if (tok.Type == TokenType.SHEETNAME)
{
tok = scanner.Scan(TokenType.SHEETNAME);
if (tok.Type != TokenType.SHEETNAME)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.SHEETNAME.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
}
tok = scanner.LookAhead(TokenType.ADDRESS, TokenType.ERR);
switch (tok.Type)
{
case TokenType.ADDRESS:
tok = scanner.Scan(TokenType.ADDRESS);
if (tok.Type != TokenType.ADDRESS)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ADDRESS.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.ERR:
tok = scanner.Scan(TokenType.ERR);
if (tok.Type != TokenType.ERR)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ERR.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
}
tok = scanner.LookAhead(TokenType.COLON);
if (tok.Type == TokenType.COLON)
{
tok = scanner.Scan(TokenType.COLON);
if (tok.Type != TokenType.COLON)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.COLON.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
tok = scanner.LookAhead(TokenType.ADDRESS, TokenType.ERR);
switch (tok.Type)
{
case TokenType.ADDRESS:
tok = scanner.Scan(TokenType.ADDRESS);
if (tok.Type != TokenType.ADDRESS)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ADDRESS.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.ERR:
tok = scanner.Scan(TokenType.ERR);
if (tok.Type != TokenType.ERR)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.ERR.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
}
}
parent.Token.UpdateRange(node.Token);
}
private void ParseExpr(ParseNode parent)
{
Token tok;
ParseNode n;
ParseNode node = parent.CreateNode(scanner.GetToken(TokenType.Expr), "Expr");
parent.Nodes.Add(node);
tok = scanner.LookAhead(TokenType.NULL, TokenType.BOOL, TokenType.NUMBER, TokenType.STRING, TokenType.PARENOPEN, TokenType.BRACEOPEN, TokenType.SHEETNAME, TokenType.ADDRESS, TokenType.ERR, TokenType.FUNC);
switch (tok.Type)
{
case TokenType.NULL:
tok = scanner.Scan(TokenType.NULL);
if (tok.Type != TokenType.NULL)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.NULL.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.BOOL:
tok = scanner.Scan(TokenType.BOOL);
if (tok.Type != TokenType.BOOL)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.BOOL.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.NUMBER:
tok = scanner.Scan(TokenType.NUMBER);
if (tok.Type != TokenType.NUMBER)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.NUMBER.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.STRING:
tok = scanner.Scan(TokenType.STRING);
if (tok.Type != TokenType.STRING)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.STRING.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.PARENOPEN:
tok = scanner.Scan(TokenType.PARENOPEN);
if (tok.Type != TokenType.PARENOPEN)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.PARENOPEN.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
ParseExpr(node);
tok = scanner.Scan(TokenType.PARENCLOSE);
if (tok.Type != TokenType.PARENCLOSE)
{
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found. Expected " + TokenType.PARENCLOSE.ToString(), 0x1001, 0, tok.StartPos, tok.StartPos, tok.Length));
}
n = node.CreateNode(tok, tok.ToString());
node.Token.UpdateRange(tok);
node.Nodes.Add(n);
break;
case TokenType.BRACEOPEN:
ParseArray(node);
break;
case TokenType.SHEETNAME:
case TokenType.ADDRESS:
case TokenType.ERR:
ParseRange(node);
break;
case TokenType.FUNC:
ParseFuncCall(node);
break;
default:
tree.Errors.Add(new ParseError("Unexpected token '" + tok.Text.Replace("\n", "") + "' found.", 0x0002, 0, tok.StartPos, tok.StartPos, tok.Length));
break;
}
parent.Token.UpdateRange(node.Token);
}