examples/fact/factparser.cpp

0001 // THIS FILE IS GENERATED
0002 // WARNING! All changes made in this file will be lost!
0003
0004 #include "factparser.h"
0005
0006
0007 #include "factlexer.h"
0008 #include <QString>
0009 #include <QDebug>
0010
0011 namespace fact
0012 {
0013
0014 void Parser::tokenize( const QString& contents )
0015 {
0016     m_contents = contents;
0017     Lexer lexer( this, contents );
0018
0019     int kind = Parser::Token_EOF;
0020     do
0021     {
0022         kind = lexer.nextTokenKind();
0023
0024         if ( !kind ) // when the lexer returns 0, the end of file is reached
0025             kind = Parser::Token_EOF;
0026
0027         Parser::Token &t = tokenStream->next();
0028         t.kind = kind;
0029         if ( t.kind == Parser::Token_EOF )
0030         {
0031             t.begin = -1;
0032             t.end = -1;
0033         }
0034         else
0035         {
0036             t.begin = lexer.tokenBegin();
0037             t.end = lexer.tokenEnd();
0038         }
0039
0040         if ( m_debug )
0041         {
0042             qDebug() << kind << "(" << t.begin << "," << t.end << ")::" << tokenText(t.begin, t.end);
0043         }
0044
0045     }
0046     while ( kind != Parser::Token_EOF );
0047
0048     this->yylex(); // produce the look ahead token
0049 }
0050
0051 QString Parser::tokenText( qint64 begin, qint64 end ) const
0052 {
0053     return m_contents.mid((int)begin, (int)end-begin+1);
0054 }
0055
0056 void Parser::reportProblem( Parser::ProblemType type, const QString& message )
0057 {
0058     if (type == Error)
0059         qDebug() << "** ERROR:" << message;
0060     else if (type == Warning)
0061         qDebug() << "** WARNING:" << message;
0062     else if (type == Info)
0063         qDebug() << "** Info:" << message;
0064 }
0065
0066 // custom error recovery
0067 void Parser::expectedToken(int /*expected*/, qint64 /*where*/, const QString& name)
0068 {
0069     reportProblem(
0070         Parser::Error,
0071         QString("Expected token \"%1\"").arg(name));
0072 }
0073
0074 void Parser::expectedSymbol(int /*expected_symbol*/, const QString& name)
0075 {
0076     qint64 line;
0077     qint64 col;
0078     size_t index = tokenStream->index()-1;
0079     Token &token = tokenStream->token(index);
0080     qDebug() << "token starts at:" << token.begin;
0081     qDebug() << "index is:" << index;
0082     tokenStream->startPosition(index, &line, &col);
0083     QString tokenValue = tokenText(token.begin, token.end);
0084     reportProblem(
0085         Parser::Error,
0086         QString("Expected symbol \"%1\" (current token: \"%2\" [%3] at line: %4 col: %5)")
0087         .arg(name)
0088         .arg(token.kind != 0 ? tokenValue : "EOF")
0089         .arg(token.kind)
0090         .arg(line)
0091         .arg(col));
0092 }
0093
0094 void Parser::setDebug( bool debug )
0095 {
0096     m_debug = debug;
0097 }
0098
0099 } // end of namespace fact
0100
0101
0102 namespace fact
0103 {
0104
0105 bool Parser::parseAssignmentStatement(AssignmentStatementAst **yynode)
0106 {
0107     *yynode = create<AssignmentStatementAst>();
0108
0109     (*yynode)->startToken = tokenStream->index() - 1;
0110     (*yynode)->id = -1;
0111
0112     if (yytoken == Token_IDENTIFIER)
0113     {
0114         if (yytoken != Token_IDENTIFIER)
0115         {
0116             expectedToken(yytoken, Token_IDENTIFIER, "identifier");
0117             return false;
0118         }
0119         (*yynode)->id = tokenStream->index() - 1;
0120         yylex();
0121
0122         if (yytoken != Token_ASSIGN)
0123         {
0124             expectedToken(yytoken, Token_ASSIGN, "=");
0125             return false;
0126         }
0127         yylex();
0128
0129         ExpressionAst *__node_0 = 0;
0130         if (!parseExpression(&__node_0))
0131         {
0132             expectedSymbol(AstNode::ExpressionKind, "expression");
0133             return false;
0134         }
0135         (*yynode)->expr = __node_0;
0136
0137         if (yytoken != Token_SEMICOLON)
0138         {
0139             expectedToken(yytoken, Token_SEMICOLON, ";");
0140             return false;
0141         }
0142         yylex();
0143
0144     }
0145     else
0146     {
0147         return false;
0148     }
0149
0150     (*yynode)->endToken = tokenStream->index() - 2;
0151
0152     return true;
0153 }
0154
0155 bool Parser::parseBlockStatement(BlockStatementAst **yynode)
0156 {
0157     *yynode = create<BlockStatementAst>();
0158
0159     (*yynode)->startToken = tokenStream->index() - 1;
0160
0161     if (yytoken == Token_LBRACE)
0162     {
0163         if (yytoken != Token_LBRACE)
0164         {
0165             expectedToken(yytoken, Token_LBRACE, "{");
0166             return false;
0167         }
0168         yylex();
0169
0170         while (yytoken == Token_IF
0171                || yytoken == Token_IDENTIFIER
0172                || yytoken == Token_RETURN
0173                || yytoken == Token_LBRACE)
0174         {
0175             StatementAst *__node_1 = 0;
0176             if (!parseStatement(&__node_1))
0177             {
0178                 expectedSymbol(AstNode::StatementKind, "statement");
0179                 return false;
0180             }
0181             (*yynode)->stmtSequence = snoc((*yynode)->stmtSequence, __node_1, memoryPool);
0182
0183         }
0184         if (yytoken != Token_RBRACE)
0185         {
0186             expectedToken(yytoken, Token_RBRACE, "}");
0187             return false;
0188         }
0189         yylex();
0190
0191     }
0192     else
0193     {
0194         return false;
0195     }
0196
0197     (*yynode)->endToken = tokenStream->index() - 2;
0198
0199     return true;
0200 }
0201
0202 bool Parser::parseBody(BodyAst **yynode)
0203 {
0204     *yynode = create<BodyAst>();
0205
0206     (*yynode)->startToken = tokenStream->index() - 1;
0207
0208     if (yytoken == Token_LBRACE)
0209     {
0210         if (yytoken != Token_LBRACE)
0211         {
0212             expectedToken(yytoken, Token_LBRACE, "{");
0213             return false;
0214         }
0215         yylex();
0216
0217         while (yytoken == Token_VAR)
0218         {
0219             DeclarationAst *__node_2 = 0;
0220             if (!parseDeclaration(&__node_2))
0221             {
0222                 expectedSymbol(AstNode::DeclarationKind, "declaration");
0223                 return false;
0224             }
0225             (*yynode)->declSequence = snoc((*yynode)->declSequence, __node_2, memoryPool);
0226
0227         }
0228         while (yytoken == Token_IF
0229                || yytoken == Token_IDENTIFIER
0230                || yytoken == Token_RETURN
0231                || yytoken == Token_LBRACE)
0232         {
0233             StatementAst *__node_3 = 0;
0234             if (!parseStatement(&__node_3))
0235             {
0236                 expectedSymbol(AstNode::StatementKind, "statement");
0237                 return false;
0238             }
0239             (*yynode)->stmtSequence = snoc((*yynode)->stmtSequence, __node_3, memoryPool);
0240
0241         }
0242         if (yytoken != Token_RBRACE)
0243         {
0244             expectedToken(yytoken, Token_RBRACE, "}");
0245             return false;
0246         }
0247         yylex();
0248
0249     }
0250     else
0251     {
0252         return false;
0253     }
0254
0255     (*yynode)->endToken = tokenStream->index() - 2;
0256
0257     return true;
0258 }
0259
0260 bool Parser::parseCondition(ConditionAst **yynode)
0261 {
0262     *yynode = create<ConditionAst>();
0263
0264     (*yynode)->startToken = tokenStream->index() - 1;
0265
0266     if (yytoken == Token_NUMBER
0267         || yytoken == Token_IDENTIFIER)
0268     {
0269         ExpressionAst *__node_4 = 0;
0270         if (!parseExpression(&__node_4))
0271         {
0272             expectedSymbol(AstNode::ExpressionKind, "expression");
0273             return false;
0274         }
0275         (*yynode)->leftExpr = __node_4;
0276
0277         if (yytoken != Token_EQUAL)
0278         {
0279             expectedToken(yytoken, Token_EQUAL, "==");
0280             return false;
0281         }
0282         yylex();
0283
0284         ExpressionAst *__node_5 = 0;
0285         if (!parseExpression(&__node_5))
0286         {
0287             expectedSymbol(AstNode::ExpressionKind, "expression");
0288             return false;
0289         }
0290         (*yynode)->rightExpr = __node_5;
0291
0292     }
0293     else
0294     {
0295         return false;
0296     }
0297
0298     (*yynode)->endToken = tokenStream->index() - 2;
0299
0300     return true;
0301 }
0302
0303 bool Parser::parseDeclaration(DeclarationAst **yynode)
0304 {
0305     *yynode = create<DeclarationAst>();
0306
0307     (*yynode)->startToken = tokenStream->index() - 1;
0308
0309     if (yytoken == Token_VAR)
0310     {
0311         if (yytoken != Token_VAR)
0312         {
0313             expectedToken(yytoken, Token_VAR, "var");
0314             return false;
0315         }
0316         yylex();
0317
0318         VariableAst *__node_6 = 0;
0319         if (!parseVariable(&__node_6))
0320         {
0321             expectedSymbol(AstNode::VariableKind, "variable");
0322             return false;
0323         }
0324         (*yynode)->var = __node_6;
0325
0326         while (yytoken == Token_COMMA)
0327         {
0328             if (yytoken != Token_COMMA)
0329             {
0330                 expectedToken(yytoken, Token_COMMA, ",");
0331                 return false;
0332             }
0333             yylex();
0334
0335             VariableAst *__node_7 = 0;
0336             if (!parseVariable(&__node_7))
0337             {
0338                 expectedSymbol(AstNode::VariableKind, "variable");
0339                 return false;
0340             }
0341             (*yynode)->var = __node_7;
0342
0343         }
0344         if (yytoken != Token_SEMICOLON)
0345         {
0346             expectedToken(yytoken, Token_SEMICOLON, ";");
0347             return false;
0348         }
0349         yylex();
0350
0351     }
0352     else
0353     {
0354         return false;
0355     }
0356
0357     (*yynode)->endToken = tokenStream->index() - 2;
0358
0359     return true;
0360 }
0361
0362 bool Parser::parseExpression(ExpressionAst **yynode)
0363 {
0364     *yynode = create<ExpressionAst>();
0365
0366     (*yynode)->startToken = tokenStream->index() - 1;
0367
0368     if (yytoken == Token_NUMBER
0369         || yytoken == Token_IDENTIFIER)
0370     {
0371         MultExpressionAst *__node_8 = 0;
0372         if (!parseMultExpression(&__node_8))
0373         {
0374             expectedSymbol(AstNode::MultExpressionKind, "multExpression");
0375             return false;
0376         }
0377         (*yynode)->leftExpr = __node_8;
0378
0379         while (yytoken == Token_MINUS)
0380         {
0381             if (yytoken != Token_MINUS)
0382             {
0383                 expectedToken(yytoken, Token_MINUS, "-");
0384                 return false;
0385             }
0386             yylex();
0387
0388             MultExpressionAst *__node_9 = 0;
0389             if (!parseMultExpression(&__node_9))
0390             {
0391                 expectedSymbol(AstNode::MultExpressionKind, "multExpression");
0392                 return false;
0393             }
0394             (*yynode)->rightExpr = __node_9;
0395
0396         }
0397     }
0398     else
0399     {
0400         return false;
0401     }
0402
0403     (*yynode)->endToken = tokenStream->index() - 2;
0404
0405     return true;
0406 }
0407
0408 bool Parser::parseFunctionDefinition(FunctionDefinitionAst **yynode)
0409 {
0410     *yynode = create<FunctionDefinitionAst>();
0411
0412     (*yynode)->startToken = tokenStream->index() - 1;
0413     (*yynode)->id = -1;
0414
0415     if (yytoken == Token_FUNCTION)
0416     {
0417         if (yytoken != Token_FUNCTION)
0418         {
0419             expectedToken(yytoken, Token_FUNCTION, "function");
0420             return false;
0421         }
0422         yylex();
0423
0424         if (yytoken != Token_IDENTIFIER)
0425         {
0426             expectedToken(yytoken, Token_IDENTIFIER, "identifier");
0427             return false;
0428         }
0429         (*yynode)->id = tokenStream->index() - 1;
0430         yylex();
0431
0432         if (yytoken != Token_LPAREN)
0433         {
0434             expectedToken(yytoken, Token_LPAREN, "(");
0435             return false;
0436         }
0437         yylex();
0438
0439         if (yytoken == Token_IDENTIFIER)
0440         {
0441             if (yytoken != Token_IDENTIFIER)
0442             {
0443                 expectedToken(yytoken, Token_IDENTIFIER, "identifier");
0444                 return false;
0445             }
0446             (*yynode)->paramSequence = snoc((*yynode)->paramSequence, tokenStream->index() - 1, memoryPool);
0447             yylex();
0448
0449             while (yytoken == Token_COMMA)
0450             {
0451                 if (yytoken != Token_COMMA)
0452                 {
0453                     expectedToken(yytoken, Token_COMMA, ",");
0454                     return false;
0455                 }
0456                 yylex();
0457
0458                 if (yytoken != Token_IDENTIFIER)
0459                 {
0460                     expectedToken(yytoken, Token_IDENTIFIER, "identifier");
0461                     return false;
0462                 }
0463                 (*yynode)->paramSequence = snoc((*yynode)->paramSequence, tokenStream->index() - 1, memoryPool);
0464                 yylex();
0465
0466             }
0467         }
0468         else if (true /*epsilon*/)
0469         {
0470         }
0471         else
0472         {
0473             return false;
0474         }
0475         if (yytoken != Token_RPAREN)
0476         {
0477             expectedToken(yytoken, Token_RPAREN, ")");
0478             return false;
0479         }
0480         yylex();
0481
0482         BodyAst *__node_10 = 0;
0483         if (!parseBody(&__node_10))
0484         {
0485             expectedSymbol(AstNode::BodyKind, "body");
0486             return false;
0487         }
0488         (*yynode)->body = __node_10;
0489
0490     }
0491     else
0492     {
0493         return false;
0494     }
0495
0496     (*yynode)->endToken = tokenStream->index() - 2;
0497
0498     return true;
0499 }
0500
0501 bool Parser::parseIfStatement(IfStatementAst **yynode)
0502 {
0503     *yynode = create<IfStatementAst>();
0504
0505     (*yynode)->startToken = tokenStream->index() - 1;
0506
0507     if (yytoken == Token_IF)
0508     {
0509         if (yytoken != Token_IF)
0510         {
0511             expectedToken(yytoken, Token_IF, "if");
0512             return false;
0513         }
0514         yylex();
0515
0516         if (yytoken != Token_LPAREN)
0517         {
0518             expectedToken(yytoken, Token_LPAREN, "(");
0519             return false;
0520         }
0521         yylex();
0522
0523         ConditionAst *__node_11 = 0;
0524         if (!parseCondition(&__node_11))
0525         {
0526             expectedSymbol(AstNode::ConditionKind, "condition");
0527             return false;
0528         }
0529         (*yynode)->cond = __node_11;
0530
0531         if (yytoken != Token_RPAREN)
0532         {
0533             expectedToken(yytoken, Token_RPAREN, ")");
0534             return false;
0535         }
0536         yylex();
0537
0538         StatementAst *__node_12 = 0;
0539         if (!parseStatement(&__node_12))
0540         {
0541             expectedSymbol(AstNode::StatementKind, "statement");
0542             return false;
0543         }
0544         (*yynode)->ifStmt = __node_12;
0545
0546         if (yytoken == Token_ELSE)
0547         {
0548             if (yytoken != Token_ELSE)
0549             {
0550                 expectedToken(yytoken, Token_ELSE, "else");
0551                 return false;
0552             }
0553             yylex();
0554
0555             StatementAst *__node_13 = 0;
0556             if (!parseStatement(&__node_13))
0557             {
0558                 expectedSymbol(AstNode::StatementKind, "statement");
0559                 return false;
0560             }
0561             (*yynode)->elseStmt = __node_13;
0562
0563         }
0564         else if (true /*epsilon*/)
0565         {
0566         }
0567         else
0568         {
0569             return false;
0570         }
0571     }
0572     else
0573     {
0574         return false;
0575     }
0576
0577     (*yynode)->endToken = tokenStream->index() - 2;
0578
0579     return true;
0580 }
0581
0582 bool Parser::parseMultExpression(MultExpressionAst **yynode)
0583 {
0584     *yynode = create<MultExpressionAst>();
0585
0586     (*yynode)->startToken = tokenStream->index() - 1;
0587
0588     if (yytoken == Token_NUMBER
0589         || yytoken == Token_IDENTIFIER)
0590     {
0591         PrimaryAst *__node_14 = 0;
0592         if (!parsePrimary(&__node_14))
0593         {
0594             expectedSymbol(AstNode::PrimaryKind, "primary");
0595             return false;
0596         }
0597         (*yynode)->leftExpr = __node_14;
0598
0599         while (yytoken == Token_STAR)
0600         {
0601             if (yytoken != Token_STAR)
0602             {
0603                 expectedToken(yytoken, Token_STAR, "*");
0604                 return false;
0605             }
0606             yylex();
0607
0608             PrimaryAst *__node_15 = 0;
0609             if (!parsePrimary(&__node_15))
0610             {
0611                 expectedSymbol(AstNode::PrimaryKind, "primary");
0612                 return false;
0613             }
0614             (*yynode)->rightExpr = __node_15;
0615
0616         }
0617     }
0618     else
0619     {
0620         return false;
0621     }
0622
0623     (*yynode)->endToken = tokenStream->index() - 2;
0624
0625     return true;
0626 }
0627
0628 bool Parser::parsePrimary(PrimaryAst **yynode)
0629 {
0630     *yynode = create<PrimaryAst>();
0631
0632     (*yynode)->startToken = tokenStream->index() - 1;
0633     (*yynode)->num = -1;
0634     (*yynode)->id = -1;
0635
0636     if (yytoken == Token_NUMBER
0637         || yytoken == Token_IDENTIFIER)
0638     {
0639         if (yytoken == Token_NUMBER)
0640         {
0641             if (yytoken != Token_NUMBER)
0642             {
0643                 expectedToken(yytoken, Token_NUMBER, "integer literal");
0644                 return false;
0645             }
0646             (*yynode)->num = tokenStream->index() - 1;
0647             yylex();
0648
0649         }
0650         else if (yytoken == Token_IDENTIFIER)
0651         {
0652             if (yytoken != Token_IDENTIFIER)
0653             {
0654                 expectedToken(yytoken, Token_IDENTIFIER, "identifier");
0655                 return false;
0656             }
0657             (*yynode)->id = tokenStream->index() - 1;
0658             yylex();
0659
0660             if (yytoken == Token_LPAREN)
0661             {
0662                 if (yytoken != Token_LPAREN)
0663                 {
0664                     expectedToken(yytoken, Token_LPAREN, "(");
0665                     return false;
0666                 }
0667                 yylex();
0668
0669                 ExpressionAst *__node_16 = 0;
0670                 if (!parseExpression(&__node_16))
0671                 {
0672                     expectedSymbol(AstNode::ExpressionKind, "expression");
0673                     return false;
0674                 }
0675                 (*yynode)->argumentSequence = snoc((*yynode)->argumentSequence, __node_16, memoryPool);
0676
0677                 while (yytoken == Token_COMMA)
0678                 {
0679                     if (yytoken != Token_COMMA)
0680                     {
0681                         expectedToken(yytoken, Token_COMMA, ",");
0682                         return false;
0683                     }
0684                     yylex();
0685
0686                     ExpressionAst *__node_17 = 0;
0687                     if (!parseExpression(&__node_17))
0688                     {
0689                         expectedSymbol(AstNode::ExpressionKind, "expression");
0690                         return false;
0691                     }
0692                     (*yynode)->argumentSequence = snoc((*yynode)->argumentSequence, __node_17, memoryPool);
0693
0694                 }
0695                 if (yytoken != Token_RPAREN)
0696                 {
0697                     expectedToken(yytoken, Token_RPAREN, ")");
0698                     return false;
0699                 }
0700                 yylex();
0701
0702             }
0703             else if (true /*epsilon*/)
0704             {
0705             }
0706             else
0707             {
0708                 return false;
0709             }
0710         }
0711         else
0712         {
0713             return false;
0714         }
0715     }
0716     else
0717     {
0718         return false;
0719     }
0720
0721     (*yynode)->endToken = tokenStream->index() - 2;
0722
0723     return true;
0724 }
0725
0726 bool Parser::parseProgram(ProgramAst **yynode)
0727 {
0728     *yynode = create<ProgramAst>();
0729
0730     (*yynode)->startToken = tokenStream->index() - 1;
0731
0732     if (yytoken == Token_FUNCTION || yytoken == Token_EOF)
0733     {
0734         while (yytoken == Token_FUNCTION)
0735         {
0736             FunctionDefinitionAst *__node_18 = 0;
0737             if (!parseFunctionDefinition(&__node_18))
0738             {
0739                 expectedSymbol(AstNode::FunctionDefinitionKind, "functionDefinition");
0740                 return false;
0741             }
0742             (*yynode)->funSequence = snoc((*yynode)->funSequence, __node_18, memoryPool);
0743
0744         }
0745         if (Token_EOF != yytoken)
0746         {
0747             return false;
0748         }
0749     }
0750     else
0751     {
0752         return false;
0753     }
0754
0755     (*yynode)->endToken = tokenStream->index() - 2;
0756
0757     return true;
0758 }
0759
0760 bool Parser::parseReturnStatement(ReturnStatementAst **yynode)
0761 {
0762     *yynode = create<ReturnStatementAst>();
0763
0764     (*yynode)->startToken = tokenStream->index() - 1;
0765
0766     if (yytoken == Token_RETURN)
0767     {
0768         if (yytoken != Token_RETURN)
0769         {
0770             expectedToken(yytoken, Token_RETURN, "return");
0771             return false;
0772         }
0773         yylex();
0774
0775         ExpressionAst *__node_19 = 0;
0776         if (!parseExpression(&__node_19))
0777         {
0778             expectedSymbol(AstNode::ExpressionKind, "expression");
0779             return false;
0780         }
0781         (*yynode)->expr = __node_19;
0782
0783         if (yytoken != Token_SEMICOLON)
0784         {
0785             expectedToken(yytoken, Token_SEMICOLON, ";");
0786             return false;
0787         }
0788         yylex();
0789
0790     }
0791     else
0792     {
0793         return false;
0794     }
0795
0796     (*yynode)->endToken = tokenStream->index() - 2;
0797
0798     return true;
0799 }
0800
0801 bool Parser::parseStatement(StatementAst **yynode)
0802 {
0803     *yynode = create<StatementAst>();
0804
0805     (*yynode)->startToken = tokenStream->index() - 1;
0806
0807     if (yytoken == Token_IF
0808         || yytoken == Token_IDENTIFIER
0809         || yytoken == Token_RETURN
0810         || yytoken == Token_LBRACE)
0811     {
0812         if (yytoken == Token_IDENTIFIER)
0813         {
0814             AssignmentStatementAst *__node_20 = 0;
0815             if (!parseAssignmentStatement(&__node_20))
0816             {
0817                 expectedSymbol(AstNode::AssignmentStatementKind, "assignmentStatement");
0818                 return false;
0819             }
0820             (*yynode)->assignStmt = __node_20;
0821
0822         }
0823         else if (yytoken == Token_IF)
0824         {
0825             IfStatementAst *__node_21 = 0;
0826             if (!parseIfStatement(&__node_21))
0827             {
0828                 expectedSymbol(AstNode::IfStatementKind, "ifStatement");
0829                 return false;
0830             }
0831             (*yynode)->ifStmt = __node_21;
0832
0833         }
0834         else if (yytoken == Token_LBRACE)
0835         {
0836             BlockStatementAst *__node_22 = 0;
0837             if (!parseBlockStatement(&__node_22))
0838             {
0839                 expectedSymbol(AstNode::BlockStatementKind, "blockStatement");
0840                 return false;
0841             }
0842             (*yynode)->blockStmt = __node_22;
0843
0844         }
0845         else if (yytoken == Token_RETURN)
0846         {
0847             ReturnStatementAst *__node_23 = 0;
0848             if (!parseReturnStatement(&__node_23))
0849             {
0850                 expectedSymbol(AstNode::ReturnStatementKind, "returnStatement");
0851                 return false;
0852             }
0853             (*yynode)->returnStmt = __node_23;
0854
0855         }
0856         else
0857         {
0858             return false;
0859         }
0860     }
0861     else
0862     {
0863         return false;
0864     }
0865
0866     (*yynode)->endToken = tokenStream->index() - 2;
0867
0868     return true;
0869 }
0870
0871 bool Parser::parseVariable(VariableAst **yynode)
0872 {
0873     *yynode = create<VariableAst>();
0874
0875     (*yynode)->startToken = tokenStream->index() - 1;
0876     (*yynode)->id = -1;
0877
0878     if (yytoken == Token_IDENTIFIER)
0879     {
0880         if (yytoken != Token_IDENTIFIER)
0881         {
0882             expectedToken(yytoken, Token_IDENTIFIER, "identifier");
0883             return false;
0884         }
0885         (*yynode)->id = tokenStream->index() - 1;
0886         yylex();
0887
0888     }
0889     else
0890     {
0891         return false;
0892     }
0893
0894     (*yynode)->endToken = tokenStream->index() - 2;
0895
0896     return true;
0897 }
0898
0899
0900 } // end of namespace fact
0901