sourcepawn2: src/compiler/Parser.cpp@bbb498ccb4ac

     1 /* vim: set ts=4 sw=4 tw=99 et:

     2  *

     3  * Copyright (C) 2012 David Anderson

     4  *

     5  * This file is part of SourcePawn.

     6  *

     7  * SourcePawn is free software: you can redistribute it and/or modify it under

     8  * the terms of the GNU General Public License as published by the Free

     9  * Software Foundation, either version 3 of the License, or (at your option)

    10  * any later version.

    11  *

    12  * SourcePawn is distributed in the hope that it will be useful, but WITHOUT ANY

    13  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    14  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

    15  *

    16  * You should have received a copy of the GNU General Public License along with

    17  * SourcePawn. If not, see http://www.gnu.org/licenses/.

    18  */

    19 #include <string.h>

    20 #include "../Zone.h"

    21 #include "../FixedArray.h"

    22 #include "../Heap.h"

    23 #include "../Strings.h"

    24 #include "../TypeManager.h"

    25 #include "Parser.h"

    26 #include "../Heap-inl.h"

    28 using namespace ke;

    30 Parser::Parser(Zone *zone, CompileContext &cc, const char *stream, size_t length)

    31   : zone_(zone),

    32     cc_(cc),

    33     pool_(zone_->pool()),

    34     scanner_(cc, stream, length),

    35     unbound_(NULL)

    36 {

    37     unbound_ = new (pool_) PoolList<NameProxy *>();

    38     imports_ = new (pool_) PoolList<ImportStatement *>();

    39 }

    41 bool

    42 Parser::peek(TokenKind kind)

    43 {

    44     return scanner_.peek() == kind;

    45 }

    47 bool

    48 Parser::match(TokenKind kind)

    49 {

    50     if (!peek(kind))

    51         return false;

    52     scanner_.scan();

    53     return true;

    54 }

    56 bool

    57 Parser::matchSemicolon()

    58 {

    59     return expect(TOK_SEMICOLON);

    60 }

    62 bool

    63 Parser::expect(TokenKind kind)

    64 {

    65     TokenKind got = scanner_.scan();

    66     if (got == kind)

    67         return true;

    68     cc_.reportError(scanner_.begin(), Message_WrongToken, TokenNames[kind], TokenNames[got]);

    69     return false;

    70 }

    72 bool

    73 Parser::matchName(String **name, TokenKind kind)

    74 {

    75     assert(kind == TOK_NAME || kind == TOK_LABEL);

    76     *name = NULL;

    77     if (!match(kind))

    78         return false;

    79     *name = zone_->makeSymbol(scanner_.literal(), scanner_.literal_length());

    80     return true;

    81 }

    83 String *

    84 Parser::expectName()

    85 {

    86     if (!expect(TOK_NAME))

    87         return NULL;

    88     return zone_->makeSymbol(scanner_.literal(), scanner_.literal_length());

    89 }

    91 Expression *

    92 Parser::primitive()

    93 {

    94     TokenKind kind = scanner_.peek();

    95     switch (kind) {

    96       case TOK_FLOAT_LITERAL:

    97       {

    98         scanner_.scan();

    99         double value = Scanner::ParseDouble(scanner_.literal());

   100         return new (pool_) FloatLiteral(scanner_.begin(), value);

   101       }

   103       case TOK_HEX_LITERAL:

   104       {

   105         scanner_.scan();

   106         int value = strtol(scanner_.literal(), NULL, 16);

   107         return new (pool_) IntegerLiteral(scanner_.begin(), value);

   108       }

   110       case TOK_INTEGER_LITERAL:

   111       {

   112         scanner_.scan();

   113         int value = atoi(scanner_.literal());

   114         return new (pool_) IntegerLiteral(scanner_.begin(), value);

   115       }

   117       case TOK_TRUE:

   118       case TOK_FALSE:

   119         scanner_.scan();

   120         return new (pool_) BooleanLiteral(scanner_.begin(), kind);

   122       case TOK_STRING_LITERAL:

   123       {

   124         scanner_.scan();

   125         Local<ByteArray> array(zone_, ByteArray::New(zone_, scanner_.literal_length() + 1));

   126         if (!array)

   127             return NULL;

   128         memcpy(array->raw(), scanner_.literal(), scanner_.literal_length() + 1);

   129         return new (pool_) StringLiteral(scanner_.begin(), array);

   130       }

   132       default:

   133       {

   134         if (kind != TOK_ERROR)

   135             cc_.reportError(scanner_.begin(), Message_ExpectedExpression, TokenNames[kind]);

   136         return NULL;

   137       }

   138     }

   139 }

   141 Expression *

   142 Parser::fixedArrayLiteral()

   143 {

   144     SourcePosition pos = scanner_.begin();

   146     ExpressionList *list = new (pool_) ExpressionList();

   147     do {

   148         // { } is an illegal array literal.

   149         if (list->length() > 0 && match(TOK_LBRACE))

   150             break;

   152         Expression *expr = NULL;

   153         if (peek(TOK_LBRACE))

   154             expr = fixedArrayLiteral();

   155         else

   156             expr = primitive();

   157         if (!expr)

   158             return NULL;

   160         if (!list->append(expr))

   161             return NULL;

   163         if (!match(TOK_COMMA)) {

   164             if (!expect(TOK_RBRACE))

   165                 return NULL;

   166             break;

   167         }

   168     } while (true);

   170     return new (pool_) ArrayLiteral(pos, TOK_LBRACE, list);

   171 }

   173 Expression *

   174 Parser::prefix()

   175 {

   176     switch (scanner_.peek()) {

   177       case TOK_LPAREN:

   178       {

   179         scanner_.scan();

   180         Expression *expr = expression();

   181         if (!expr)

   182             return NULL;

   183         if (!expect(TOK_RPAREN))

   184             return NULL;

   185         return expr;

   186       }

   188       case TOK_NAME:

   189       {

   190         Local<String> name(zone_, expectName());

   191         if (!name)

   192             return NULL;

   193         return new (pool_) NameProxy(scanner_.begin(), name);

   194       }

   196       default:

   197         return primitive();

   198     }

   199 }

   201 // Parses only old-style declarations.

   202 bool

   203 Parser::typeAndName(Expression **type, String **namep)

   204 {

   205     if (match(TOK_LABEL)) {

   206         // Old-style declaration:

   207         //   new X:type

   208         Local<String> name(zone_, zone_->makeSymbol(scanner_.literal(), scanner_.literal_length()));

   209         if (!name)

   210             return false;

   212         *type = new (pool_) NameProxy(scanner_.begin(), name);

   213         *namep = expectName();

   214         return !!*namep;

   215     }

   217     *type = NULL;

   218     *namep = expectName();

   220     return !!*namep;

   221 }

   223 // Parses both old and new style declarations.

   224 bool

   225 Parser::fullTypeAndName(Expression **type, String **namep, DeclKind kind)

   226 {

   227     // Declaration:

   228     //   NewDecl ::= Type Ident

   229     //   OldDecl ::= Label? (Ident | "...")

   230     //   Type    ::= Ident

   231     //   Label   ::= Ident ":"

   232     //

   233     if (match(TOK_LABEL)) {

   234         // We something of the form:

   235         //     Label Ident

   236         // or: Label "..."

   237         Local<String> name(zone_, zone_->makeSymbol(scanner_.literal(), scanner_.literal_length()));

   238         if (!name)

   239             return false;

   241         *type = new (pool_) NameProxy(scanner_.begin(), name);

   242         if (kind == DeclArg && match(TOK_ELLIPSES)) {

   243             *namep = NULL;

   244         } else {

   245             if ((*namep = expectName()) == NULL)

   246                 return false;

   247         }

   248         return true;

   249     }

   251     Local<String> name(zone_, expectName());

   252     if (!name)

   253         return false;

   255     if (peek(TOK_NAME) || (kind == DeclArg && peek(TOK_ELLIPSES))) {

   256         // We got something of the form:

   257         //    Ident Ident

   258         *type = new (pool_) NameProxy(scanner_.begin(), name);

   259         if (peek(TOK_NAME)) {

   260             if ((*namep = expectName()) == NULL)

   261                 return false;

   262         } else {

   263             *namep = NULL;

   264         }

   265         return true;

   266     }

   268     // We got something of the form:

   269     //    Ident

   270     *type = NULL;

   271     *namep = name;

   272     return true;

   273 }

   275 Expression *

   276 Parser::call(Expression *callee)

   277 {

   278     ExpressionList *arguments = new (pool_) ExpressionList();

   280     SourcePosition pos = scanner_.begin();

   281     expect(TOK_LPAREN);

   283     if (!match(TOK_RPAREN)) {

   284         while (true) {

   285             Expression *expr = expression();

   286             if (!expr)

   287                 return NULL;

   289             if (!arguments->append(expr))

   290                 return NULL;

   292             if (!match(TOK_COMMA))

   293                 break;

   294         }

   296         if (!expect(TOK_RPAREN))

   297             return NULL;

   298     }

   300     return new (pool_) CallExpression(pos, callee, arguments);

   301 }

   303 Expression *

   304 Parser::index(Expression *left)

   305 {

   306     expect(TOK_LBRACKET);

   308     SourcePosition pos = scanner_.begin();

   309     Expression *expr = expression();

   310     if (!expr)

   311         return NULL;

   313     if (!expect(TOK_RBRACKET))

   314         return NULL;

   316     return new (pool_) IndexExpression(pos, left, expr);

   317 }

   319 Expression *

   320 Parser::field(Expression *left)

   321 {

   322     expect(TOK_DOT);

   324     SourcePosition pos = scanner_.begin();

   325     Local<String> name(zone_, expectName());

   326     if (!name)

   327         return NULL;

   329     return new (pool_) FieldExpression(pos, left, name);

   330 }

   332 Expression *

   333 Parser::primary()

   334 {

   335     Expression *expr = prefix();

   336     if (!expr)

   337         return NULL;

   339     for (;;) {

   340         switch (scanner_.peek()) {

   341           case TOK_LPAREN:

   342             if ((expr = call(expr)) == NULL)

   343                 return NULL;

   344             break;

   346           case TOK_LBRACKET:

   347             if ((expr = index(expr)) == NULL)

   348                 return NULL;

   349             break;

   351           case TOK_DOT:

   352             if ((expr = field(expr)) == NULL)

   353                 return NULL;

   354             break;

   356           default:

   357             return expr;

   358         }

   359     }

   360 }

   362 Expression *

   363 Parser::unary()

   364 {

   365     TokenKind token = scanner_.peek();

   367     SourcePosition pos = scanner_.begin();

   368     switch (token) {

   369       case TOK_INCREMENT:

   370       case TOK_DECREMENT:

   371       {

   372         scanner_.scan();

   373         Expression *expr = unary();

   374         if (!expr)

   375             return NULL;

   376         return new (pool_) IncDecExpression(pos, token, expr, false);

   377       }

   379       case TOK_MINUS:

   380       case TOK_NOT:

   381       case TOK_TILDE:

   382       {

   383         scanner_.scan();

   384         Expression *expr = unary();

   385         if (!expr)

   386             return NULL;

   387         return new (pool_) UnaryExpression(pos, token, expr);

   388       }

   390       case TOK_SIZEOF:

   391       {

   392         scanner_.scan();

   393         if (!expect(TOK_LPAREN))

   394             return NULL;

   395         Expression *expr = unary();

   396         if (!expr)

   397             return NULL;

   398         if (!expect(TOK_RPAREN))

   399             return NULL;

   400         return new (pool_) UnaryExpression(pos, token, expr);

   401       }

   403       case TOK_LABEL:

   404       {

   405         scanner_.scan();

   406         Local<String> tag(zone_, zone_->makeSymbol(scanner_.literal(), scanner_.literal_length()));

   407         if (!tag)

   408             return NULL;

   410         NameProxy *proxy = new (pool_) NameProxy(scanner_.begin(), tag);

   412         Expression *expr = unary();

   413         if (!expr)

   414             return NULL;

   416         return new (pool_) UnaryExpression(pos, TOK_LABEL, expr, proxy);

   417       }

   419       default:

   420         break;

   421     }

   423     Expression *expr = primary();

   425     token = scanner_.peek();

   426     if (token == TOK_INCREMENT || token == TOK_DECREMENT) {

   427         scanner_.scan();

   428         return new (pool_) IncDecExpression(pos, token, expr, true);

   429     }

   431     return expr;

   432 }

   434 Expression *

   435 Parser::multiplication()

   436 {

   437     Expression *left = unary();

   438     do {

   439         if (!match(TOK_SLASH) && !match(TOK_STAR) && !match(TOK_PERCENT))

   440             break;

   441         SourcePosition pos = scanner_.begin();

   442         TokenKind kind = scanner_.last();

   443         Expression *right = unary();

   444         if (!right)

   445             return NULL;

   446         left = new (pool_) BinaryExpression(pos, kind, left, right);

   447     } while (left);

   448     return left;

   449 }

   451 Expression *

   452 Parser::addition()

   453 {

   454     Expression *left = multiplication();

   455     while (left) {

   456         if (!match(TOK_PLUS) && !match(TOK_MINUS))

   457             break;

   458         SourcePosition pos = scanner_.begin();

   459         TokenKind kind = scanner_.last();

   460         Expression *right = multiplication();

   461         if (!right)

   462             return NULL;

   463         left = new (pool_) BinaryExpression(pos, kind, left, right);

   464     }

   465     return left;

   466 }

   468 Expression *

   469 Parser::shift()

   470 {

   471     Expression *left = addition();

   472     while (left) {

   473         if (!match(TOK_SHL) && !match(TOK_SHR) && !match(TOK_USHR))

   474             break;

   475         SourcePosition pos = scanner_.begin();

   476         TokenKind kind = scanner_.last();

   477         Expression *right = addition();

   478         if (!right)

   479             return NULL;

   480         left = new (pool_) BinaryExpression(pos, kind, left, right);

   481     }

   482     return left;

   483 }

   485 Expression *

   486 Parser::bitand_()

   487 {

   488     Expression *left = shift();

   489     while (left) {

   490         if (!match(TOK_BITAND))

   491             break;

   492         SourcePosition pos = scanner_.begin();

   493         Expression *right = shift();

   494         if (!right)

   495             return NULL;

   496         left = new (pool_) BinaryExpression(pos, TOK_BITAND, left, right);

   497     }

   498     return left;

   499 }

   501 Expression *

   502 Parser::bitxor()

   503 {

   504     Expression *left = bitand_();

   505     while (left) {

   506         if (!match(TOK_BITXOR))

   507             break;

   508         SourcePosition pos = scanner_.begin();

   509         Expression *right = shift();

   510         if (!right)

   511             return NULL;

   512         left = new (pool_) BinaryExpression(pos, TOK_BITXOR, left, right);

   513     }

   514     return left;

   515 }

   517 Expression *

   518 Parser::bitor_()

   519 {

   520     Expression *left = bitxor();

   521     while (left) {

   522         if (!match(TOK_BITOR))

   523             break;

   524         SourcePosition pos = scanner_.begin();

   525         Expression *right = bitxor();

   526         if (!right)

   527             return NULL;

   528         left = new (pool_) BinaryExpression(pos, TOK_BITOR, left, right);

   529     }

   530     return left;

   531 }

   533 Expression *

   534 Parser::relational()

   535 {

   536     Expression *left = bitor_();

   537     while (left) {

   538         TokenKind kind = scanner_.peek();

   539         if (kind < TOK_LT || kind > TOK_GE)

   540             break;

   541         scanner_.scan();

   542         SourcePosition pos = scanner_.begin();

   543         Expression *right = shift();

   544         if (!right)

   545             return NULL;

   546         left = new (pool_) BinaryExpression(pos, kind, left, right);

   547     }

   548     return left;

   549 }

   551 Expression *

   552 Parser::equals()

   553 {

   554     Expression *left = relational();

   555     while (left) {

   556         if (!match(TOK_EQUALS) && !match(TOK_NOTEQUALS))

   557             break;

   558         TokenKind kind = scanner_.last();

   559         SourcePosition pos = scanner_.begin();

   560         Expression *right = relational();

   561         if (!right)

   562             return NULL;

   563         left = new (pool_) BinaryExpression(pos, kind, left, right);

   564     }

   565     return left;

   566 }

   568 Expression *

   569 Parser::and_()

   570 {

   571     Expression *left = equals();

   572     while (left) {

   573         if (!match(TOK_AND))

   574             break;

   575         SourcePosition pos = scanner_.begin();

   576         Expression *right = equals();

   577         if (!right)

   578             return NULL;

   579         left = new (pool_) BinaryExpression(pos, TOK_AND, left, right);

   580     }

   581     return left;

   582 }

   584 Expression *

   585 Parser::or_()

   586 {

   587     Expression *left = and_();

   588     while (left) {

   589         if (!match(TOK_OR))

   590             break;

   591         SourcePosition pos = scanner_.begin();

   592         Expression *right = and_();

   593         if (!right)

   594             return NULL;

   595         left = new (pool_) BinaryExpression(pos, TOK_OR, left, right);

   596     }

   597     return left;

   598 }

   600 Expression *

   601 Parser::ternary()

   602 {

   603     Expression *cond = or_();

   604     if (!cond)

   605         return NULL;

   607     if (!match(TOK_QMARK))

   608         return cond;

   610     Expression *left;

   611     SourcePosition pos = scanner_.begin();

   612     AutoAllowTags<false> disableTags(scanner_);

   613     {

   614         if ((left = expression()) == NULL)

   615             return NULL;

   616     }

   618     if (!expect(TOK_COLON))

   619         return NULL;

   621     Expression *right = expression();

   622     if (!right)

   623         return NULL;

   625     return new (pool_) TernaryExpression(pos, cond, left, right);

   626 }

   628 Expression *

   629 Parser::assignment()

   630 {

   631     Expression *left = ternary();

   632     while (left) {

   633         TokenKind token = scanner_.peek();

   634         if (token != TOK_ASSIGN && (token < TOK_ASSIGN_ADD || token > TOK_ASSIGN_SHL))

   635             break;

   636         scanner_.scan();

   637         SourcePosition pos = scanner_.begin();

   638         Expression *expr = ternary();

   639         if (!expr)

   640             return NULL;

   642         left = new (pool_) Assignment(pos, token, left, expr);

   643     }

   644     return left;

   645 }

   647 Expression *

   648 Parser::expression()

   649 {

   650     return assignment();

   651 }

   653 Statement *

   654 Parser::while_()

   655 {

   656     SourcePosition pos = scanner_.begin();

   657     scanner_.scan();

   659     if (!expect(TOK_LPAREN))

   660         return NULL;

   662     Expression *condition = expression();

   663     if (!condition)

   664         return NULL;

   666     if (!expect(TOK_RPAREN))

   667         return NULL;

   669     Statement *body;

   670     if (scanner_.peek() == TOK_LBRACE)

   671         body = block();

   672     else

   673         body = localStatement();

   674     if (!body)

   675         return NULL;

   677     return new (pool_) WhileStatement(pos, TOK_WHILE, condition, body);

   678 }

   680 Statement *

   681 Parser::do_()

   682 {

   683     SourcePosition pos = scanner_.begin();

   684     scanner_.scan();

   686     Statement *body;

   687     if (scanner_.peek() == TOK_LBRACE)

   688         body = block();

   689     else

   690         body = localStatement();

   691     if (!body)

   692         return NULL;

   694     if (!expect(TOK_WHILE))

   695         return NULL;

   697     if (!expect(TOK_LPAREN))

   698         return NULL;

   699     Expression *condition = expression();

   700     if (!condition)

   701         return NULL;

   702     if (!expect(TOK_RPAREN))

   703         return NULL;

   705     return new (pool_) WhileStatement(pos, TOK_DO, condition, body);

   706 }

   708 Statement *

   709 Parser::switch_()

   710 {

   711     expect(TOK_SWITCH);

   713     SourcePosition pos = scanner_.begin();

   715     if (!expect(TOK_LPAREN))

   716         return NULL;

   717     Expression *expr = expression();

   718     if (!expr)

   719         return NULL;

   720     if (!expect(TOK_RPAREN))

   721         return NULL;

   723     if (!expect(TOK_LBRACE))

   724         return NULL;

   726     SourcePosition defaultPos;

   727     PoolList<Case *> *cases = new (pool_) PoolList<Case *>();

   729     Statement *defaultCase = NULL;

   731     while (!peek(TOK_RBRACE)) {

   732         Expression *expr = NULL;

   733         ExpressionList *others = NULL;

   734         if (match(TOK_DEFAULT)) {

   735             if (defaultCase) {

   736                 cc_.reportError(scanner_.begin(), Message_OneDefaultPerSwitch);

   737                 return NULL;

   738             }

   740             defaultPos = scanner_.begin();

   741         } else {

   742             if (defaultCase) {

   743                 cc_.reportError(defaultPos, Message_DefaultMustBeLastCase);

   744                 return NULL;

   745             }

   747             if (!expect(TOK_CASE))

   748                 return NULL;

   750             // A limitation in the grammar is that |case <NAME>:| will be

   751             // detected as a label.

   752             AutoAllowTags<false> disableTags(scanner_);

   754             if ((expr = expression()) == NULL)

   755                 return NULL;

   757             if (peek(TOK_COMMA)) {

   758                 others = new (pool_) ExpressionList();

   759                 while (match(TOK_COMMA)) {

   760                     Expression *other = expression();

   761                     if (!other)

   762                         return NULL;

   763                     if (!others->append(other))

   764                         return NULL;

   765                 }

   766             }

   767         }

   769         if (!expect(TOK_COLON))

   770             return NULL;

   772         Statement *statement = localStatement();

   773         if (!statement)

   774             return NULL;

   776         if (!peek(TOK_CASE) &&

   777             !peek(TOK_DEFAULT) &&

   778             !peek(TOK_RBRACE))

   779         {

   780             cc_.reportError(scanner_.begin(), Message_SingleStatementPerCase);

   781             return NULL;

   782         }

   784         if (expr) {

   785             Case *caze = new (pool_) Case(expr, others, statement);

   786             if (!cases->append(caze))

   787                 return NULL;

   788         } else {

   789             defaultCase = statement;

   790         }

   791     }

   793     if (!expect(TOK_RBRACE))

   794         return NULL;

   796     return new (pool_) SwitchStatement(pos, expr, cases, defaultCase);

   797 }

   799 Statement *

   800 Parser::forStatement()

   801 {

   802     SourcePosition pos = scanner_.begin();

   803     scanner_.scan();

   804     if (!expect(TOK_LPAREN))

   805         return NULL;

   807     Statement *decl = NULL;

   808     if (!match(TOK_SEMICOLON)) {

   809         if (match(TOK_NEW)) {

   810             if ((decl = vars(Qual_None)) == NULL)

   811                 return NULL;

   812         } else {

   813             if ((decl = expressionStatement()) == NULL)

   814                 return NULL;

   815         }

   816         if (!expect(TOK_SEMICOLON))

   817             return NULL;

   818     }

   820     Expression *condition = NULL;

   821     if (!match(TOK_SEMICOLON)) {

   822         if ((condition = expression()) == NULL)

   823             return NULL;

   824         if (!expect(TOK_SEMICOLON))

   825             return NULL;

   826     }

   828     Statement *update = NULL;

   829     if (!match(TOK_RPAREN)) {

   830         if ((update = expressionStatement()) == NULL)

   831             return NULL;

   832         if (!expect(TOK_RPAREN))

   833             return NULL;

   834     }

   836     Statement *body;

   837     if (scanner_.peek() == TOK_LBRACE)

   838         body = block();

   839     else

   840         body = localStatement();

   841     if (!body)

   842         return NULL;

   844     return new (pool_) ForStatement(pos, decl, condition, update, body);

   845 }

   847 ExpressionList *

   848 Parser::dimensions()

   849 {

   850     ExpressionList *postDimensions = new (pool_) ExpressionList();

   851     while (match(TOK_LBRACKET)) {

   852         Expression *dim = NULL;

   853         if (!match(TOK_RBRACKET)) {

   854             if ((dim = expression()) == NULL)

   855                 return NULL;

   856             if (!expect(TOK_RBRACKET))

   857                 return NULL;

   858         }

   860         if (!postDimensions->append(dim))

   861             return NULL;

   862     }

   863     return postDimensions;

   864 }

   866 VariableDeclaration *

   867 Parser::var(TypeQualifiers qual)

   868 {

   869     Expression *type;

   870     Local<String> name(zone_);

   872     if (!typeAndName(&type, name.ref()))

   873         return NULL;

   875     ExpressionList *dims = NULL;

   876     if (peek(TOK_LBRACKET)) {

   877         if ((dims = dimensions()) == NULL)

   878             return NULL;;

   879     }

   881     SourcePosition pos = scanner_.begin();

   883     Expression *expr = NULL;

   884     if (match(TOK_ASSIGN)) {

   885         switch (scanner_.peek()) {

   886           // Note: we don't support [] literals yet.

   887           case TOK_LBRACE:

   888             scanner_.scan();

   889             if ((expr = fixedArrayLiteral()) == NULL)

   890                 return NULL;

   891             break;

   893           default:

   894             if ((expr = expression()) == NULL)

   895                 return NULL;

   896             break;

   897         }

   898     }

   900     return new (pool_) VariableDeclaration(pos, qual, name, type, dims, expr);

   901 }

   903 Statement *

   904 Parser::vars(TypeQualifiers qual)

   905 {

   906     VariableDeclaration *decl = var(qual);

   907     if (!decl)

   908         return NULL;

   910     if (!peek(TOK_COMMA))

   911         return decl;

   913     StatementList *statements = new (pool_) StatementList();

   914     if (!statements->append(decl))

   915         return NULL;

   917     while (match(TOK_COMMA)) {

   918         Statement *decl = var(qual);

   919         if (!decl)

   920             return NULL;

   921         if (!statements->append(decl))

   922             return NULL;

   923     }

   925     // Create a fake-o block with no scope to create a statement list.

   926     return new (pool_) BlockStatement(decl->pos(), statements);

   927 }

   929 Statement *

   930 Parser::returnStatement()

   931 {

   932     SourcePosition pos = scanner_.begin();

   933     if (!expect(TOK_RETURN))

   934         return NULL;

   936     Expression *expr = NULL;

   937     if (scanner_.peek() != TOK_SEMICOLON) {

   938         if ((expr = expression()) == NULL)

   939             return NULL;

   941         // We only care about non-void returns when determining whether a

   942         // tagless function is non-void.

   943         encounteredReturn_ = true;

   944     }

   946     return new (pool_) ReturnStatement(pos, expr);

   947 }

   949 Statement *

   950 Parser::expressionStatement()

   951 {

   952     Expression *left = assignment();

   953     if (!left)

   954         return NULL;

   956     return new (pool_) ExpressionStatement(left);

   957 }

   959 Statement *

   960 Parser::block()

   961 {

   962     if (!expect(TOK_LBRACE))

   963         return NULL;

   965     SourcePosition pos = scanner_.begin();

   967     StatementList *statements = new (pool_) StatementList();

   968     while (!match(TOK_RBRACE)) {

   969         Statement *statement = localStatement();

   970         if (statement == NULL)

   971             return NULL;

   972         if (!statements->append(statement))

   973             return NULL;

   974     }

   976     BlockStatement *block = new (pool_) BlockStatement(pos, statements);

   977     return block;

   978 }

   980 Statement *

   981 Parser::if_()

   982 {

   983     expect(TOK_IF);

   985     SourcePosition pos = scanner_.begin();

   986     if (!expect(TOK_LPAREN))

   987         return NULL;

   989     Expression *cond = expression();

   990     if (!cond)

   991         return NULL;

   993     if (!expect(TOK_RPAREN))

   994         return NULL;

   996     Statement *ifTrue = localStatement();

   997     if (!ifTrue)

   998         return NULL;

  1000     IfStatement *outer = new (pool_) IfStatement(pos, cond, ifTrue);

  1002     IfStatement *last = outer;

  1003     while (match(TOK_ELSE)) {

  1004         if (!match(TOK_IF)) {

  1005             Statement *ifFalse = localStatement();

  1006             if (!ifFalse)

  1007                 return NULL;

  1009             last->setIfFalse(ifFalse);

  1010             break;

  1011         }

  1013         SourcePosition pos = scanner_.begin();

  1014         if (!expect(TOK_LPAREN))

  1015             return NULL;

  1017         Expression *otherCond = expression();

  1018         if (!otherCond)

  1019             return NULL;

  1021         if (!expect(TOK_RPAREN))

  1022             return NULL;

  1024         Statement *otherIfTrue = localStatement();

  1025         if (!otherIfTrue)

  1026             return NULL;

  1028         IfStatement *inner = new (pool_) IfStatement(pos, otherCond, otherIfTrue);

  1029         last->setIfFalse(inner);

  1030         last = inner;

  1031     }

  1033     return outer;

  1034 }

  1036 Statement *

  1037 Parser::localStatement()

  1038 {

  1039     Statement *statement = NULL;

  1041     // Statements which must be followed by a semicolon will break out of the

  1042     // switch. If they may end in BlockStatements, they'll immediately return.

  1044     TokenKind kind = scanner_.peek();

  1045     switch (kind) {

  1046       case TOK_CONST:

  1047       case TOK_NEW:

  1048       {

  1049         TypeQualifiers quals = (kind == TOK_CONST)

  1050                               ? Qual_Const

  1051                               : Qual_None;

  1052         scanner_.scan();

  1053         if ((statement = vars(quals)) == NULL)

  1054           return NULL;

  1055         break;

  1056       }

  1058       case TOK_FOR:

  1059         return forStatement();

  1061       case TOK_WHILE:

  1062         return while_();

  1064       case TOK_BREAK:

  1065         scanner_.scan();

  1066         statement = new (pool_) BreakStatement(scanner_.begin());

  1067         break;

  1069       case TOK_CONTINUE:

  1070         scanner_.scan();

  1071         statement = new (pool_) ContinueStatement(scanner_.begin());

  1072         break;

  1074       case TOK_DO:

  1075         if ((statement = do_()) == NULL)

  1076             return NULL;

  1077         break;

  1079       case TOK_RETURN:

  1080         if ((statement = returnStatement()) == NULL)

  1081           return NULL;

  1082         break;

  1084       case TOK_ENUM:

  1085         if ((statement = enum_()) == NULL)

  1086           return NULL;

  1087         break;

  1089       case TOK_STRUCT:

  1090         if ((statement = struct_()) == NULL)

  1091           return NULL;

  1092         break;

  1094       case TOK_SWITCH:

  1095         return switch_();

  1097       case TOK_IF:

  1098         return if_();

  1100       case TOK_LBRACE:

  1101         return block();

  1103       default:

  1104         break;

  1105     }

  1107     if (!statement) {

  1108         if ((statement = expressionStatement()) == NULL)

  1109             return NULL;

  1110     }

  1112     if (!expect(TOK_SEMICOLON))

  1113         return NULL;

  1115     return statement;

  1116 }

  1118 Statement *

  1119 Parser::struct_()

  1120 {

  1121     expect(TOK_STRUCT);

  1123     Local<String> name(zone_, expectName());

  1124     if (!name)

  1125         return NULL;

  1127     SourcePosition pos = scanner_.begin();

  1129     if (!expect(TOK_LBRACE))

  1130         return NULL;

  1132     FieldList *fields = new (pool_) FieldList();

  1134     while (!peek(TOK_RBRACE)) {

  1135         Expression *type;

  1136         Local<String> fieldName(zone_);

  1138         if (!fullTypeAndName(&type, fieldName.ref(), DeclField))

  1139             return NULL;

  1141         SourcePosition pos = scanner_.begin();

  1143         if (!matchSemicolon())

  1144             return NULL;

  1146         StructureStatement::Field *field =

  1147             new (pool_) StructureStatement::Field(pos, type, fieldName);

  1148         if (!field || !fields->append(field))

  1149             return NULL;

  1150     }

  1152     if (!expect(TOK_RBRACE))

  1153         return NULL;

  1155     if (fields->empty()) {

  1156         cc_.reportError(pos, Message_StructCantBeEmpty);

  1157         return NULL;

  1158     }

  1160     return new (pool_) StructureStatement(pos, name, fields);

  1161 }

  1163 Statement *

  1164 Parser::enum_()

  1165 {

  1166     expect(TOK_ENUM);

  1168     SourcePosition pos = scanner_.begin();

  1170     Local<String> name(zone_);

  1171     if (matchName(name.ref()) && !name)

  1172         return NULL;

  1174     EnumStatement::EntryList *entries = new (pool_) EnumStatement::EntryList();

  1176     if (!expect(TOK_LBRACE))

  1177         return NULL;

  1179     do {

  1180         if (scanner_.peek() == TOK_RBRACE)

  1181             break;

  1183         SourcePosition &pos = scanner_.begin();

  1184         Local<String> name(zone_, expectName());

  1185         if (!name)

  1186             return NULL;

  1188         Expression *expr = NULL;

  1189         if (match(TOK_ASSIGN)) {

  1190             if ((expr = expression()) == NULL)

  1191                 return NULL;

  1192         }

  1194         if (!entries->append(EnumStatement::Entry(name, expr, pos)))

  1195             return NULL;

  1196     } while (match(TOK_COMMA));

  1197     if (!expect(TOK_RBRACE))

  1198         return NULL;

  1200     return new (pool_) EnumStatement(pos, name, entries);

  1201 }

  1203 template <class T>

  1204 static inline ScopedRoot<T> *

  1205 NewScopedRoot(PoolAllocator &pool, Handle<T> obj)

  1206 {

  1207     ScopedRoot<T> *root = pool.alloc<ScopedRoot<T> >();

  1208     new (root) ScopedRoot<T>(obj);

  1209     return root;

  1210 }

  1212 ImportStatement *

  1213 Parser::import()

  1214 {

  1215     NameList *names = new (pool_) NameList();

  1217     SourcePosition pos = scanner_.begin();

  1219     Local<String> name(zone_, expectName());

  1220     if (!name || !names->append(NewScopedRoot<String>(pool_, name)))

  1221         return NULL;

  1223     TokenKind suffix = TOK_NONE;

  1224     while (match(TOK_DOT)) {

  1225         if (match(TOK_STAR)) {

  1226             suffix = TOK_STAR;

  1227             break;

  1228         }

  1230         if ((name = expectName()) == NULL)

  1231             return NULL;

  1233         if (!names->append(NewScopedRoot<String>(pool_, name)))

  1234             return NULL;

  1235     }

  1237     return new (pool_) ImportStatement(pos, names, suffix);

  1238 }

  1240 Statement *

  1241 Parser::function(TokenKind token)

  1242 {

  1243     Expression *returnType;

  1244     Local<String> name(zone_);

  1246     if (!fullTypeAndName(&returnType, name.ref(), DeclFun))

  1247         return NULL;

  1249     SourcePosition pos = scanner_.begin();

  1250     ParameterList *parameters = new (pool_) ParameterList();

  1252     if (!expect(TOK_LPAREN))

  1253         return NULL;

  1255     bool variadic = false;

  1257     if (!match(TOK_RPAREN)) {

  1258         while (true) {

  1259             bool isConst = match(TOK_CONST);

  1260             bool ref = match(TOK_AMPERSAND);

  1262             SourcePosition begin = scanner_.begin();

  1263             Expression *type;

  1264             Local<String> name(zone_);

  1265             if (!fullTypeAndName(&type, name.ref(), DeclArg))

  1266                 return NULL;

  1268             if (!name) {

  1269                 if (isConst || ref) {

  1270                     cc_.reportError(begin, Message_InvalidVarArgs);

  1271                     return NULL;

  1272                 }

  1274                 if (token != TOK_NATIVE) {

  1275                     cc_.reportError(begin, Message_VarArgsOutsideNative);

  1276                     return NULL;

  1277                 }

  1279                 variadic = true;

  1280                 break;

  1281             }

  1283             ExpressionList *dims = NULL;

  1284             if (peek(TOK_LBRACKET)) {

  1285                 if ((dims = dimensions()) == NULL)

  1286                     return NULL;

  1287             }

  1289             Expression *expr = NULL;

  1290             if (match(TOK_ASSIGN)) {

  1291                 if ((expr = expression()) == NULL)

  1292                     return NULL;

  1293             }

  1295             Parameter *parameter = new (pool_) Parameter(name, type, ref, isConst, dims, expr, begin);

  1296             if (!parameters->append(parameter))

  1297                 return NULL;

  1299             if (!match(TOK_COMMA))

  1300                 break;

  1301         }

  1302         if (!expect(TOK_RPAREN))

  1303             return NULL;

  1304     }

  1306     encounteredReturn_ = false;

  1308     Statement *body = NULL;

  1309     if (token != TOK_FORWARD && token != TOK_NATIVE && token != TOK_TYPEDEF) {

  1310         body = block();

  1311         if (!body)

  1312             return NULL;

  1313     }

  1315     FunctionSignature signature(returnType, parameters, variadic);

  1316     if (token == TOK_TYPEDEF)

  1317         return new (pool_) FunctionTypeStatement(pos, name, signature);

  1319     return new (pool_) FunctionStatement(pos, name, token, body, signature, encounteredReturn_);

  1320 }

  1322 static inline bool

  1323 DeclareIntrinsicType(Zone *zone, Scope *scope, const char *name, Handle<Type> type)

  1324 {

  1325     Local<String> tag(zone, zone->makeSymbol(name));

  1326     if (!tag)

  1327         return false;

  1329     assert(false);

  1330     return false; //return !!scope->declareType(tag, type);

  1331 }

  1333 static inline bool

  1334 DeclareIntrinsicType(Zone *zone, Scope *scope, const char *name, PrimitiveType type)

  1335 {

  1336     Local<Type> primitive(zone, zone->types()->getPrimitive(type));

  1337     assert(primitive);

  1338     return DeclareIntrinsicType(zone, scope, name, primitive);

  1339 }

  1341 bool

  1342 Parser::setupIntrinsics()

  1343 {

  1344 #if 0

  1345     if (!DeclareIntrinsicType(zone_, scope_, "Float", PrimitiveType_Float))

  1346         return false;

  1347     if (!DeclareIntrinsicType(zone_, scope_, "_", PrimitiveType_Int32))

  1348         return false;

  1349     if (!DeclareIntrinsicType(zone_, scope_, "bool", PrimitiveType_Bool))

  1350         return false;

  1351     if (!DeclareIntrinsicType(zone_, scope_, "String", PrimitiveType_Char))

  1352         return false;

  1354     Local<Type> unchecked(zone_, zone_->types()->getUnchecked());

  1355     if (!DeclareIntrinsicType(zone_, scope_, "unchecked", unchecked))

  1356         return false;

  1358     Local<Type> voidType(zone_, zone_->types()->getVoid());

  1359     if (!DeclareIntrinsicType(zone_, scope_, "void", voidType))

  1360         return false;

  1362     Local<Type> intType(zone_, zone_->types()->getPrimitive(PrimitiveType_Int32));

  1363     if (!DeclareIntrinsicType(zone_, scope_, "int", intType))

  1364         return false;

  1365 #endif

  1366     return true;

  1367 }

  1369 ParseTree *

  1370 Parser::parse()

  1371 {

  1372     StatementList *statements = new (pool_) StatementList();

  1374     if (!setupIntrinsics())

  1375         return NULL;

  1377     for (;;) {

  1378         Statement *statement = NULL;

  1380         TokenKind kind = scanner_.peek();

  1381         switch (kind) {

  1382           case TOK_ERROR:

  1383             return NULL;

  1385           case TOK_EOF:

  1386             break;

  1388           case TOK_NAME:

  1389             if ((statement = function(TOK_NAME)) == NULL)

  1390                 return NULL;

  1391             break;

  1393           case TOK_IMPORT:

  1394           {

  1395             scanner_.scan();

  1396             if (statements->length())

  1397                 cc_.reportError(scanner_.begin(), Message_ImportsMustBeFirst);

  1398             ImportStatement *stmt = import();

  1399             if (!stmt)

  1400                 return NULL;

  1401             if (!imports_->append(stmt))

  1402                 return NULL;

  1403             if (!matchSemicolon())

  1404                 return NULL;

  1405             continue;

  1406           }

  1408           case TOK_FORWARD:

  1409           case TOK_PUBLIC:

  1410           case TOK_NATIVE:

  1411           case TOK_STOCK:

  1412           case TOK_LABEL:

  1413           case TOK_TYPEDEF:

  1414           {

  1415             if (kind != TOK_LABEL)

  1416                 scanner_.scan();

  1417             if (kind == TOK_PUBLIC && peek(TOK_CONST)) {

  1418                 TypeQualifiers quals = TypeQualifiers(Qual_Public | Qual_Const);

  1419                 if ((statement = var(quals)) == NULL)

  1420                     return NULL;

  1421                 if (!matchSemicolon())

  1422                     return NULL;

  1423             } else {

  1424                 if ((statement = function(kind)) == NULL)

  1425                     return NULL;

  1426                 if ((kind == TOK_FORWARD || kind == TOK_NATIVE || kind == TOK_TYPEDEF) && !matchSemicolon())

  1427                     return NULL;

  1428             }

  1429             break;

  1430           }

  1432           case TOK_CONST:

  1433           case TOK_NEW:

  1434           {

  1435             TypeQualifiers quals = (kind == TOK_NEW) ? Qual_Const : Qual_None;

  1436             // Note: at global scope, we don't accept comma-delimited

  1437             // declarations yet, to see if we can get away with forcing

  1438             // a nicer top-level style.

  1439             scanner_.scan();

  1440             if ((statement = var(quals)) == NULL)

  1441                 return NULL;

  1442             if (!matchSemicolon())

  1443                 return NULL;

  1444             break;

  1445           }

  1447           case TOK_ENUM:

  1448             if ((statement = enum_()) == NULL)

  1449                 return NULL;

  1450             if (!matchSemicolon())

  1451                 return NULL;

  1452             break;

  1454           case TOK_STRUCT:

  1455             if ((statement = struct_()) == NULL)

  1456                 return NULL;

  1457             if (!matchSemicolon())

  1458                 return NULL;

  1459             break;

  1461           default:

  1462             cc_.reportError(scanner_.begin(), Message_ExpectedGlobal);

  1463             return NULL;

  1464         }

  1466         if (!statement)

  1467             break;

  1469         if (!statements->append(statement))

  1470             return NULL;

  1471     }

  1473     return new (pool_) ParseTree(statements, unbound_, imports_);

  1474 }

  1476 class AstPrinter : public AstVisitor

  1477 {

  1478     FILE *fp_;

  1479     size_t level_;

  1481   private:

  1482     void prefix() {

  1483         for (size_t i = 0; i < level_; i++)

  1484             fprintf(fp_, "  ");

  1485     }

  1486     void indent() {

  1487         level_++;

  1488     }

  1489     void unindent() {

  1490         level_--;

  1491     }

  1493   public:

  1494     AstPrinter(FILE *fp)

  1495       : fp_(fp),

  1496         level_(0)

  1497     {

  1498     }

  1500     void dump(const FunctionSignature &sig) {

  1501         prefix();

  1502         fprintf(fp_, "()\n");

  1503     }

  1504     void visitNameProxy(NameProxy *name) {

  1505         prefix();

  1506         fprintf(fp_, "[ NameProxy (%s)\n", name->name()->chars());

  1507     }

  1508     void visitCallExpression(CallExpression *node) {

  1509         prefix();

  1510         fprintf(fp_, "[ CallExpression\n");

  1511         indent();

  1512         node->callee()->accept(this);

  1513         for (size_t i = 0; i < node->arguments()->length(); i++)

  1514             node->arguments()->at(i)->accept(this);

  1515         unindent();

  1516     }

  1517     void visitFunctionTypeStatement(FunctionTypeStatement *node) {

  1518         prefix();

  1519         fprintf(fp_, "[ FunctionTypeStatement (%s)\n", node->name()->chars());

  1520         indent();

  1521         dump(node->signature());

  1522         unindent();

  1523     }

  1524     void visitFunctionStatement(FunctionStatement *node) {

  1525         prefix();

  1526         fprintf(fp_, "[ FunctionStatement (%s)\n", node->name()->chars());

  1527         indent();

  1528         dump(node->signature());

  1529         if (node->body())

  1530             node->body()->accept(this);

  1531         unindent();

  1532     }

  1533     void visitExpressionStatement(ExpressionStatement *node) {

  1534         prefix();

  1535         fprintf(fp_, "[ ExpressionStatement\n");

  1536         indent();

  1537         node->expression()->accept(this);

  1538         unindent();

  1539     }

  1540     void visitAssignment(Assignment *node) {

  1541         prefix();

  1542         fprintf(fp_, "[ Assignment\n");

  1543         indent();

  1544         node->lvalue()->accept(this);

  1545         node->expression()->accept(this);

  1546         unindent();

  1547     }

  1548     void visitTernaryExpression(TernaryExpression *node) {

  1549         prefix();

  1550         fprintf(fp_, "[ TernaryExpression\n");

  1551         indent();

  1552         node->condition()->accept(this);

  1553         node->left()->accept(this);

  1554         node->right()->accept(this);

  1555         unindent();

  1556     }

  1557     void visitBinaryExpression(BinaryExpression *node) {

  1558         prefix();

  1559         fprintf(fp_, "[ BinaryExpression (%s)\n", TokenNames[node->token()]);

  1560         indent();

  1561         node->left()->accept(this);

  1562         node->right()->accept(this);

  1563         unindent();

  1564     }

  1565     void visitUnaryExpression(UnaryExpression *node) {

  1566         prefix();

  1567         fprintf(fp_, "[ UnaryExpression (%s)\n", TokenNames[node->token()]);

  1568         indent();

  1569         node->expression()->accept(this);

  1570         unindent();

  1571     }

  1572     void visitReturnStatement(ReturnStatement *node) {

  1573         prefix();

  1574         fprintf(fp_, "[ ReturnStatement\n");

  1575         indent();

  1576         if (node->expression())

  1577             node->expression()->accept(this);

  1578         unindent();

  1579     }

  1580     void visitForStatement(ForStatement *node) {

  1581         prefix();

  1582         fprintf(fp_, "[ ForStatement\n");

  1583         indent();

  1584         if (node->initialization())

  1585             node->initialization()->accept(this);

  1586         if (node->condition())

  1587             node->condition()->accept(this);

  1588         if (node->update())

  1589             node->update()->accept(this);

  1590         node->body()->accept(this);

  1591         unindent();

  1592     }

  1593     void visitBlockStatement(BlockStatement *node) {

  1594         prefix();

  1595         fprintf(fp_, "[ BlockStatement\n");

  1596         indent();

  1597         for (size_t i = 0; i < node->statements()->length(); i++)

  1598             node->statements()->at(i)->accept(this);

  1599         unindent();

  1600     }

  1601     void visitVariableDeclaration(VariableDeclaration *node) {

  1602         prefix();

  1603         fprintf(fp_, "[ VariableDeclaration (%s)\n", node->name()->chars());

  1604         indent();

  1605         if (node->initialization())

  1606             node->initialization()->accept(this);

  1607         unindent();

  1608     }

  1609     void visitIntegerLiteral(IntegerLiteral *node) {

  1610         prefix();

  1611         fprintf(fp_, "[ IntegerLiteral (%d)\n", node->value());

  1612     }

  1613     void visitBooleanLiteral(BooleanLiteral *node) {

  1614         prefix();

  1615         fprintf(fp_, "[ BooleanLiteral (%s)\n",

  1616                 (node->token() == TOK_TRUE) ? "true" : "false");

  1617     }

  1618     void visitFloatLiteral(FloatLiteral *node) {

  1619         prefix();

  1620         fprintf(fp_, "[ FloatLiteral (%f)\n", node->value());

  1621     }

  1622     void visitIfStatement(IfStatement *node) {

  1623         prefix();

  1624         fprintf(fp_, "[ IfStatement\n");

  1625         indent();

  1626         node->ifTrue()->accept(this);

  1627         if (node->ifFalse())

  1628             node->ifFalse()->accept(this);

  1629         unindent();

  1630     }

  1631     void visitIndexExpression(IndexExpression *node) {

  1632         prefix();

  1633         fprintf(fp_, "[ IndexExpression\n");

  1634         indent();

  1635         node->left()->accept(this);

  1636         node->right()->accept(this);

  1637         unindent();

  1638     }

  1639     void visitEnumStatement(EnumStatement *node) {

  1640         prefix();

  1641         fprintf(fp_, "[ EnumStatement (%s)\n", node->name() ? node->name()->chars() : "<anonymous>");

  1642         indent();

  1643         for (size_t i = 0; i < node->entries()->length(); i++) {

  1644             prefix();

  1645             fprintf(fp_, "%s =\n", node->entries()->at(i).name->chars());

  1646             if (node->entries()->at(i).expr) {

  1647                 indent();

  1648                 node->entries()->at(i).expr->accept(this);

  1649                 unindent();

  1650             }

  1651         }

  1652         unindent();

  1653     }

  1654     void visitWhileStatement(WhileStatement *node) {

  1655         prefix();

  1656         fprintf(fp_, "[ WhileStatement (%s)\n",

  1657                 (node->token() == TOK_DO) ? "do" : "while");

  1658         indent();

  1659         if (node->token() == TOK_DO) {

  1660             node->condition()->accept(this);

  1661             node->body()->accept(this);

  1662         } else {

  1663             node->condition()->accept(this);

  1664             node->body()->accept(this);

  1665         }

  1666         unindent();

  1667     }

  1668     void visitBreakStatement(BreakStatement *node) {

  1669         prefix();

  1670         fprintf(fp_, "[ BreakStatement\n");

  1671     }

  1672     void visitContinueStatement(ContinueStatement *node) {

  1673         prefix();

  1674         fprintf(fp_, "[ ContinueStatement\n");

  1675     }

  1676     void visitStringLiteral(StringLiteral *node) {

  1677         prefix();

  1678         fprintf(fp_, "[ StringLiteral\n");

  1679     }

  1680     void visitIncDecExpression(IncDecExpression *node) {

  1681         prefix();

  1682         fprintf(fp_, "[ IncDecExpression (postfix=%d)\n", node->postfix());

  1683         indent();

  1684         node->expression()->accept(this);

  1685         unindent();

  1686     }

  1687     void visitStructureStatement(StructureStatement *node) {

  1688         prefix();

  1689         fprintf(fp_, "[ StructureStatement %s\n", node->name()->chars());

  1690     }

  1691     void visitFieldExpression(FieldExpression *node) {

  1692         prefix();

  1693         fprintf(fp_, "[ FieldExpression %s\n", node->field()->chars());

  1694         indent();

  1695         node->left()->accept(this);

  1696         unindent();

  1697     }

  1698     void visitSwitchStatement(SwitchStatement *node) {

  1699         prefix();

  1700         fprintf(fp_, "[ SwitchStatement\n");

  1701         indent();

  1702         node->expression()->accept(this);

  1703         for (size_t i = 0; i < node->cases()->length(); i++) {

  1704             Case *c = node->cases()->at(i);

  1705             c->expression()->accept(this);

  1706             if (c->others()) {

  1707                 for (size_t j = 0; j < c->others()->length(); j++)

  1708                     c->others()->at(j)->accept(this);

  1709             }

  1710             indent();

  1711             c->statement()->accept(this);

  1712             unindent();

  1713         }

  1714         if (node->defaultCase())

  1715             node->defaultCase()->accept(this);

  1716         unindent();

  1717     }

  1718     void visitArrayLiteral(ArrayLiteral *node) {

  1719         prefix();

  1720         fprintf(fp_, "[ ArrayLiteral\n");

  1721         indent();

  1722         for (size_t i = 0; i < node->expressions()->length(); i++) {

  1723             Expression *expr = node->expressions()->at(i);

  1724             indent();

  1725             expr->accept(this);

  1726             unindent();

  1727         }

  1728     }

  1729     void visitImportStatement(ImportStatement *node) {

  1730         prefix();

  1731         fprintf(fp_, "[ ImportStatement\n");

  1732     }

  1733 };

  1735 void

  1736 ParseTree::dump(FILE *fp)

  1737 {

  1738     AstPrinter printer(fp);

  1740     for (size_t i = 0; i < statements_->length(); i++)

  1741         statements_->at(i)->accept(&printer);

  1742 }

author	David Anderson <dvander@alliedmods.net>
	Sat Dec 22 23:18:57 2012 -0800 (2012-12-22)
changeset 233	bbb498ccb4ac
parent 220	5df4a112967d
child 234	26e3035cdffc
permissions	-rw-r--r--