~groovestomp/c-parser

28d79988bc63199b84721b5c909094dc36914e4a — Aaron Oman 7 months ago 8ce8c28
Re-indent parser.c
1 files changed, 403 insertions(+), 403 deletions(-)

M src/parser.c
M src/parser.c => src/parser.c +403 -403
@@ 105,10 105,10 @@ bool TypedefAddName(char *name) {

/*
  constant:
          integer-constant
          character-constant
          floating-constant
          enumeration-constant
  integer-constant
  character-constant
  floating-constant
  enumeration-constant
*/
bool ParseConstant(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 138,8 138,8 @@ bool ParseArgumentExpressionListI(Tokenizer *tokenizer, ParseTreeNode *parse_tre
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ArgumentExpressionListI, 3);

        if (Token_Comma == (token = GetToken(tokenizer)).type &&
           ParseAssignmentExpression(tokenizer, &parse_tree->children[1]) &&
           ParseArgumentExpressionListI(tokenizer, &parse_tree->children[2])) {
            ParseAssignmentExpression(tokenizer, &parse_tree->children[1]) &&
            ParseArgumentExpressionListI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 150,8 150,8 @@ bool ParseArgumentExpressionListI(Tokenizer *tokenizer, ParseTreeNode *parse_tre

/*
  argument-expression-list:
          assignment-expression
          argument-expression-list , assignment-expression
  assignment-expression
  argument-expression-list , assignment-expression
*/
bool ParseArgumentExpressionList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 159,7 159,7 @@ bool ParseArgumentExpressionList(Tokenizer *tokenizer, ParseTreeNode *parse_tree
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ArgumentExpressionList, 2);

        if (ParseAssignmentExpression(tokenizer, &parse_tree->children[0]) &&
           ParseArgumentExpressionListI(tokenizer, &parse_tree->children[1])) {
            ParseArgumentExpressionListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 169,10 169,10 @@ bool ParseArgumentExpressionList(Tokenizer *tokenizer, ParseTreeNode *parse_tree

/*
  primary-expression:
          identifier
          constant
          string
          ( expression )
  identifier
  constant
  string
  ( expression )
*/
bool ParsePrimaryExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 196,8 196,8 @@ bool ParsePrimaryExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           ParseExpression(tokenizer, &parse_tree->children[1]) &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type) {
            ParseExpression(tokenizer, &parse_tree->children[1]) &&
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 214,9 214,9 @@ bool ParsePostfixExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_PostfixExpressionI, 4);

        if (Token_OpenBracket == (tokens[0] = GetToken(tokenizer)).type &&
           ParseExpression(tokenizer, &parse_tree->children[1]) &&
           Token_CloseBracket == (tokens[0] = GetToken(tokenizer)).type &&
           ParsePostfixExpressionI(tokenizer, &parse_tree->children[3])) {
            ParseExpression(tokenizer, &parse_tree->children[1]) &&
            Token_CloseBracket == (tokens[0] = GetToken(tokenizer)).type &&
            ParsePostfixExpressionI(tokenizer, &parse_tree->children[3])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 224,9 224,9 @@ bool ParsePostfixExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           ParseArgumentExpressionList(tokenizer, &parse_tree->children[1]) &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParsePostfixExpressionI(tokenizer, &parse_tree->children[3])) {
            ParseArgumentExpressionList(tokenizer, &parse_tree->children[1]) &&
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParsePostfixExpressionI(tokenizer, &parse_tree->children[3])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 236,8 236,8 @@ bool ParsePostfixExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParsePostfixExpressionI(tokenizer, &parse_tree->children[2])) {
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParsePostfixExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 245,8 245,8 @@ bool ParsePostfixExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_Dot == (tokens[0] = GetToken(tokenizer)).type &&
           Token_Identifier == (tokens[1] = GetToken(tokenizer)).type &&
           ParsePostfixExpressionI(tokenizer, &parse_tree->children[2])) {
            Token_Identifier == (tokens[1] = GetToken(tokenizer)).type &&
            ParsePostfixExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Identifier, tokens[1]);
                return true;


@@ 254,8 254,8 @@ bool ParsePostfixExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_Arrow == (tokens[0] = GetToken(tokenizer)).type &&
           Token_Identifier == (tokens[1] = GetToken(tokenizer)).type &&
           ParsePostfixExpressionI(tokenizer, &parse_tree->children[2])) {
            Token_Identifier == (tokens[1] = GetToken(tokenizer)).type &&
            ParsePostfixExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Identifier, tokens[1]);
                return true;


@@ 265,14 265,14 @@ bool ParsePostfixExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_PlusPlus == (tokens[0] = GetToken(tokenizer)).type &&
           ParsePostfixExpressionI(tokenizer, &parse_tree->children[1])) {
            ParsePostfixExpressionI(tokenizer, &parse_tree->children[1])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                return true;
        }

        *tokenizer = start;
        if (Token_MinusMinus == (tokens[0] = GetToken(tokenizer)).type &&
           ParsePostfixExpressionI(tokenizer, &parse_tree->children[1])) {
            ParsePostfixExpressionI(tokenizer, &parse_tree->children[1])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                return true;
        }


@@ 283,13 283,13 @@ bool ParsePostfixExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  postfix-expression:
          primary-expression
          postfix-expression [ expression ]
          postfix-expression ( argument-expression-list(opt) )
          postfix-expression . identifier
          postfix-expression -> identifier
          postfix-expression ++
          postfix-expression --
  primary-expression
  postfix-expression [ expression ]
  postfix-expression ( argument-expression-list(opt) )
  postfix-expression . identifier
  postfix-expression -> identifier
  postfix-expression ++
  postfix-expression --
*/
bool ParsePostfixExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 297,7 297,7 @@ bool ParsePostfixExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_PostfixExpression, 2);

        if (ParsePrimaryExpression(tokenizer, &parse_tree->children[0]) &&
           ParsePostfixExpressionI(tokenizer, &parse_tree->children[1])) {
            ParsePostfixExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 329,12 329,12 @@ bool ParseUnaryOperator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  unary-expression:
          postfix-expression
          ++ unary-expression
          -- unary-expression
          unary-operator cast-expression
          sizeof unary-expression
          sizeof ( type-name )
  postfix-expression
  ++ unary-expression
  -- unary-expression
  unary-operator cast-expression
  sizeof unary-expression
  sizeof ( type-name )
*/
bool ParseUnaryExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 350,7 350,7 @@ bool ParseUnaryExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_PlusPlus == (tokens[0] = GetToken(tokenizer)).type &&
           ParseUnaryExpression(tokenizer, &parse_tree->children[1])) {
            ParseUnaryExpression(tokenizer, &parse_tree->children[1])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                return true;
        }


@@ 359,7 359,7 @@ bool ParseUnaryExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_MinusMinus == (tokens[0] = GetToken(tokenizer)).type &&
           ParseUnaryExpression(tokenizer, &parse_tree->children[1])) {
            ParseUnaryExpression(tokenizer, &parse_tree->children[1])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                return true;
        }


@@ 368,7 368,7 @@ bool ParseUnaryExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (ParseUnaryOperator(tokenizer, &parse_tree->children[0]) &&
           ParseCastExpression(tokenizer, &parse_tree->children[1])) {
            ParseCastExpression(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 377,7 377,7 @@ bool ParseUnaryExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        *tokenizer = start;
        tokens[0] = GetToken(tokenizer);
        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("sizeof", tokens[0].text, gs_StringLength("sizeof"))) {
            gs_StringIsEqual("sizeof", tokens[0].text, gs_StringLength("sizeof"))) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Keyword, tokens[0]);

                Tokenizer Previous = *tokenizer;


@@ 387,8 387,8 @@ bool ParseUnaryExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

                *tokenizer = Previous;
                if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
                   ParseTypeName(tokenizer, &parse_tree->children[2]) &&
                   Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type) {
                    ParseTypeName(tokenizer, &parse_tree->children[2]) &&
                    Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type) {
                        ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[0]);
                        ParseTreeSet(&parse_tree->children[3], ParseTreeNode_Symbol, tokens[1]);
                        return true;


@@ 401,8 401,8 @@ bool ParseUnaryExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  cast-expression:
          unary-expression
          ( type-name ) cast-expression
  unary-expression
  ( type-name ) cast-expression
*/
bool ParseCastExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 416,9 416,9 @@ bool ParseCastExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           ParseTypeName(tokenizer, &parse_tree->children[1]) &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseCastExpression(tokenizer, &parse_tree->children[3])) {
            ParseTypeName(tokenizer, &parse_tree->children[1]) &&
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseCastExpression(tokenizer, &parse_tree->children[3])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 435,24 435,24 @@ bool ParseMultiplicativeExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_t
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_MultiplicativeExpression, 3);

        if (Token_Asterisk == (token = GetToken(tokenizer)).type &&
           ParseCastExpression(tokenizer, &parse_tree->children[1]) &&
           ParseMultiplicativeExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseCastExpression(tokenizer, &parse_tree->children[1]) &&
            ParseMultiplicativeExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }

        *tokenizer = start;
        if (Token_Slash == (token = GetToken(tokenizer)).type &&
           ParseCastExpression(tokenizer, &parse_tree->children[1]) &&
           ParseMultiplicativeExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseCastExpression(tokenizer, &parse_tree->children[1]) &&
            ParseMultiplicativeExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }

        *tokenizer = start;
        if (Token_PercentSign == (token = GetToken(tokenizer)).type &&
           ParseCastExpression(tokenizer, &parse_tree->children[1]) &&
           ParseMultiplicativeExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseCastExpression(tokenizer, &parse_tree->children[1]) &&
            ParseMultiplicativeExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 463,10 463,10 @@ bool ParseMultiplicativeExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_t

/*
  multiplicative-expression:
          cast-expression
          multiplicative-expression * cast-expression
          multiplicative-expression / cast-expression
          multiplicative-expression % cast-expression
  cast-expression
  multiplicative-expression * cast-expression
  multiplicative-expression / cast-expression
  multiplicative-expression % cast-expression
*/
bool ParseMultiplicativeExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 474,7 474,7 @@ bool ParseMultiplicativeExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tr
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_MultiplicativeExpression, 2);

        if (ParseCastExpression(tokenizer, &parse_tree->children[0]) &&
           ParseMultiplicativeExpressionI(tokenizer, &parse_tree->children[1])) {
            ParseMultiplicativeExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 489,16 489,16 @@ bool ParseAdditiveExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_AdditiveExpressionI, 3);

        if (Token_Cross == (token = GetToken(tokenizer)).type &&
           ParseMultiplicativeExpression(tokenizer, &parse_tree->children[1]) &&
           ParseAdditiveExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseMultiplicativeExpression(tokenizer, &parse_tree->children[1]) &&
            ParseAdditiveExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }

        *tokenizer = start;
        if (Token_Dash == (token = GetToken(tokenizer)).type &&
           ParseMultiplicativeExpression(tokenizer, &parse_tree->children[1]) &&
           ParseAdditiveExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseMultiplicativeExpression(tokenizer, &parse_tree->children[1]) &&
            ParseAdditiveExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 509,9 509,9 @@ bool ParseAdditiveExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  additive-expression:
          multiplicative-expression
          additive-expression + multiplicative-expression
          additive-expression - multiplicative-expression
  multiplicative-expression
  additive-expression + multiplicative-expression
  additive-expression - multiplicative-expression
*/
bool ParseAdditiveExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 519,7 519,7 @@ bool ParseAdditiveExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_AdditiveExpression, 2);

        if (ParseMultiplicativeExpression(tokenizer, &parse_tree->children[0]) &&
           ParseAdditiveExpressionI(tokenizer, &parse_tree->children[1])) {
            ParseAdditiveExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 534,16 534,16 @@ bool ParseShiftExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ShiftExpressionI, 3);

        if (Token_BitShiftLeft == (token = GetToken(tokenizer)).type &&
           ParseAdditiveExpression(tokenizer, &parse_tree->children[1]) &&
           ParseShiftExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseAdditiveExpression(tokenizer, &parse_tree->children[1]) &&
            ParseShiftExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }

        *tokenizer = start;
        if (Token_BitShiftRight == (token = GetToken(tokenizer)).type &&
           ParseAdditiveExpression(tokenizer, &parse_tree->children[1]) &&
           ParseShiftExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseAdditiveExpression(tokenizer, &parse_tree->children[1]) &&
            ParseShiftExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 554,9 554,9 @@ bool ParseShiftExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  shift-expression:
          additive-expression
          shift-expression << additive-expression
          shift-expression >> additive-expression
  additive-expression
  shift-expression << additive-expression
  shift-expression >> additive-expression
*/
bool ParseShiftExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 564,7 564,7 @@ bool ParseShiftExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ShiftExpression, 2);

        if (ParseAdditiveExpression(tokenizer, &parse_tree->children[0]) &&
           ParseShiftExpressionI(tokenizer, &parse_tree->children[1])) {
            ParseShiftExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 579,32 579,32 @@ bool ParseRelationalExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree)
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_RelationalExpressionI, 3);

        if (Token_LessThan == (token = GetToken(tokenizer)).type &&
           ParseShiftExpression(tokenizer, &parse_tree->children[1]) &&
           ParseRelationalExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseShiftExpression(tokenizer, &parse_tree->children[1]) &&
            ParseRelationalExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }

        *tokenizer = start;
        if (Token_GreaterThan == (token = GetToken(tokenizer)).type &&
           ParseShiftExpression(tokenizer, &parse_tree->children[1]) &&
           ParseRelationalExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseShiftExpression(tokenizer, &parse_tree->children[1]) &&
            ParseRelationalExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }

        *tokenizer = start;
        if (Token_LessThanEqual == (token = GetToken(tokenizer)).type &&
           ParseShiftExpression(tokenizer, &parse_tree->children[1]) &&
           ParseRelationalExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseShiftExpression(tokenizer, &parse_tree->children[1]) &&
            ParseRelationalExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }

        *tokenizer = start;
        if (Token_GreaterThanEqual == (token = GetToken(tokenizer)).type &&
           ParseShiftExpression(tokenizer, &parse_tree->children[1]) &&
           ParseRelationalExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseShiftExpression(tokenizer, &parse_tree->children[1]) &&
            ParseRelationalExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 615,11 615,11 @@ bool ParseRelationalExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree)

/*
  relational-expression:
          shift-expression
          relational-expression < shift-expression
          relational-expression > shift-expression
          relational-expression <= shift-exression
          relational-expression >= shift-expression
  shift-expression
  relational-expression < shift-expression
  relational-expression > shift-expression
  relational-expression <= shift-exression
  relational-expression >= shift-expression
*/
bool ParseRelationalExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 627,7 627,7 @@ bool ParseRelationalExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) 
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_RelationalExpression, 2);

        if (ParseShiftExpression(tokenizer, &parse_tree->children[0]) &&
           ParseRelationalExpressionI(tokenizer, &parse_tree->children[1])) {
            ParseRelationalExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 642,16 642,16 @@ bool ParseEqualityExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_EqualityExpressionI, 3);

        if (Token_LogicalEqual == (token = GetToken(tokenizer)).type &&
           ParseRelationalExpression(tokenizer, &parse_tree->children[1]) &&
           ParseEqualityExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseRelationalExpression(tokenizer, &parse_tree->children[1]) &&
            ParseEqualityExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }

        *tokenizer = start;
        if (Token_NotEqual == (token = GetToken(tokenizer)).type &&
           ParseRelationalExpression(tokenizer, &parse_tree->children[1]) &&
           ParseEqualityExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseRelationalExpression(tokenizer, &parse_tree->children[1]) &&
            ParseEqualityExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 662,9 662,9 @@ bool ParseEqualityExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  equality-expression:
          relational-expression
          equality-expression == relational-expression
          equality-expression != relational-expression
  relational-expression
  equality-expression == relational-expression
  equality-expression != relational-expression
*/
bool ParseEqualityExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 672,7 672,7 @@ bool ParseEqualityExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_EqualityExpression, 2);

        if (ParseRelationalExpression(tokenizer, &parse_tree->children[0]) &&
           ParseEqualityExpressionI(tokenizer, &parse_tree->children[1])) {
            ParseEqualityExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 687,8 687,8 @@ bool ParseAndExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_AndExpressionI, 3);

        if (Token_Ampersand == (token = GetToken(tokenizer)).type &&
           ParseEqualityExpression(tokenizer, &parse_tree->children[1]) &&
           ParseAndExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseEqualityExpression(tokenizer, &parse_tree->children[1]) &&
            ParseAndExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 699,8 699,8 @@ bool ParseAndExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  AND-expression:
          equality-expression
          AND-expression & equality-expression
  equality-expression
  AND-expression & equality-expression
*/
bool ParseAndExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 708,7 708,7 @@ bool ParseAndExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_AndExpression, 2);

        if (ParseEqualityExpression(tokenizer, &parse_tree->children[0]) &&
           ParseAndExpressionI(tokenizer, &parse_tree->children[1])) {
            ParseAndExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 723,8 723,8 @@ bool ParseExclusiveOrExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ExclusiveOrExpressionI, 3);

        if (Token_Carat == (token = GetToken(tokenizer)).type &&
           ParseAndExpression(tokenizer, &parse_tree->children[1]) &&
           ParseExclusiveOrExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseAndExpression(tokenizer, &parse_tree->children[1]) &&
            ParseExclusiveOrExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 735,16 735,16 @@ bool ParseExclusiveOrExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree

/*
  exclusive-OR-expression
          AND-expression
          exclusive-OR-expression ^ AND-expression
 */
  AND-expression
  exclusive-OR-expression ^ AND-expression
*/
bool ParseExclusiveOrExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;

        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ExclusiveOrExpression, 2);

        if (ParseAndExpression(tokenizer, &parse_tree->children[0]) &&
           ParseExclusiveOrExpressionI(tokenizer, &parse_tree->children[1])) {
            ParseExclusiveOrExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 759,8 759,8 @@ bool ParseInclusiveOrExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_InclusiveOrExpressionI, 3);

        if (Token_Pipe == (token = GetToken(tokenizer)).type &&
           ParseExclusiveOrExpression(tokenizer, &parse_tree->children[1]) &&
           ParseInclusiveOrExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseExclusiveOrExpression(tokenizer, &parse_tree->children[1]) &&
            ParseInclusiveOrExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 771,8 771,8 @@ bool ParseInclusiveOrExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree

/*
  inclusive-OR-expression:
          exclusive-OR-expression
          inclusive-OR-expression | exclusive-OR-expression
  exclusive-OR-expression
  inclusive-OR-expression | exclusive-OR-expression
*/
bool ParseInclusiveOrExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 780,7 780,7 @@ bool ParseInclusiveOrExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree)
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_InclusiveOrExpression, 2);

        if (ParseExclusiveOrExpression(tokenizer, &parse_tree->children[0]) &&
           ParseInclusiveOrExpressionI(tokenizer, &parse_tree->children[1])) {
            ParseInclusiveOrExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 795,8 795,8 @@ bool ParseLogicalAndExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree)
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_LogicalAndExpressionI, 3);

        if (Token_LogicalAnd == (token = GetToken(tokenizer)).type &&
           ParseInclusiveOrExpression(tokenizer, &parse_tree->children[1]) &&
           ParseLogicalAndExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseInclusiveOrExpression(tokenizer, &parse_tree->children[1]) &&
            ParseLogicalAndExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 807,8 807,8 @@ bool ParseLogicalAndExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree)

/*
  logical-AND-expression:
          inclusive-OR-expression
          logical-AND-expression && inclusive-OR-expression
  inclusive-OR-expression
  logical-AND-expression && inclusive-OR-expression
*/
bool ParseLogicalAndExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 816,7 816,7 @@ bool ParseLogicalAndExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) 
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_LogicalAndExpression, 2);

        if (ParseInclusiveOrExpression(tokenizer, &parse_tree->children[0]) &&
           ParseLogicalAndExpressionI(tokenizer, &parse_tree->children[1])) {
            ParseLogicalAndExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 831,8 831,8 @@ bool ParseLogicalOrExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) 
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_LogicalOrExpressionI, 3);

        if (Token_LogicalOr == (token = GetToken(tokenizer)).type &&
           ParseLogicalAndExpression(tokenizer, &parse_tree->children[1]) &&
           ParseLogicalOrExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseLogicalAndExpression(tokenizer, &parse_tree->children[1]) &&
            ParseLogicalOrExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 843,8 843,8 @@ bool ParseLogicalOrExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) 

/*
  logical-OR-expression:
          logical-AND-expression
          logical-OR-expression || logical-AND-expression
  logical-AND-expression
  logical-OR-expression || logical-AND-expression
*/
bool ParseLogicalOrExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 852,7 852,7 @@ bool ParseLogicalOrExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_LogicalOrExpression, 2);

        if (ParseLogicalAndExpression(tokenizer, &parse_tree->children[0]) &&
           ParseLogicalOrExpressionI(tokenizer, &parse_tree->children[1])) {
            ParseLogicalOrExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 862,7 862,7 @@ bool ParseLogicalOrExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  constant-expression:
          conditional-expression
  conditional-expression
*/
bool ParseConstantExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 879,8 879,8 @@ bool ParseConstantExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  conditional-expression:
          logical-OR-expression
          logical-OR-expression ? expression : conditional-expression
  logical-OR-expression
  logical-OR-expression ? expression : conditional-expression
*/
bool ParseConditionalExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 889,10 889,10 @@ bool ParseConditionalExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree)
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ConditionalExpression, 5);

        if (ParseLogicalOrExpression(tokenizer, &parse_tree->children[0]) &&
           Token_QuestionMark == (tokens[0] = GetToken(tokenizer)).type &&
           ParseExpression(tokenizer, &parse_tree->children[2]) &&
           Token_Colon == (tokens[1] = GetToken(tokenizer)).type &&
           ParseConditionalExpression(tokenizer, &parse_tree->children[4])) {
            Token_QuestionMark == (tokens[0] = GetToken(tokenizer)).type &&
            ParseExpression(tokenizer, &parse_tree->children[2]) &&
            Token_Colon == (tokens[1] = GetToken(tokenizer)).type &&
            ParseConditionalExpression(tokenizer, &parse_tree->children[4])) {
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[3], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 940,8 940,8 @@ bool ParseAssignmentOperator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  assignment-expression:
          conditional-expression
          unary-expression assignment-operator assignment-expression
  conditional-expression
  unary-expression assignment-operator assignment-expression
*/
bool ParseAssignmentExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 949,8 949,8 @@ bool ParseAssignmentExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) 
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_AssignmentExpression, 3);

        if (ParseUnaryExpression(tokenizer, &parse_tree->children[0]) &&
           ParseAssignmentOperator(tokenizer, &parse_tree->children[1]) &&
           ParseAssignmentExpression(tokenizer, &parse_tree->children[2])) {
            ParseAssignmentOperator(tokenizer, &parse_tree->children[1]) &&
            ParseAssignmentExpression(tokenizer, &parse_tree->children[2])) {
                return true;
        }



@@ 972,8 972,8 @@ bool ParseExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ExpressionI, 3);

        if (Token_Comma == (token = GetToken(tokenizer)).type &&
           ParseAssignmentExpression(tokenizer, &parse_tree->children[1]) &&
           ParseExpressionI(tokenizer, &parse_tree->children[2])) {
            ParseAssignmentExpression(tokenizer, &parse_tree->children[1]) &&
            ParseExpressionI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 984,8 984,8 @@ bool ParseExpressionI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  expression:
          assignment-expression
          expression , assignment-expression
  assignment-expression
  expression , assignment-expression
*/
bool ParseExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 993,7 993,7 @@ bool ParseExpression(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_Expression, 2);

        if (ParseAssignmentExpression(tokenizer, &parse_tree->children[0]) &&
           ParseExpressionI(tokenizer, &parse_tree->children[1])) {
            ParseExpressionI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1016,10 1016,10 @@ bool ParseIdentifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  jump-statement:
          goto identifier ;
          continue ;
          break ;
          return expression(opt) ;
  goto identifier ;
  continue ;
  break ;
  return expression(opt) ;
*/
bool ParseJumpStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1030,9 1030,9 @@ bool ParseJumpStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_JumpStatement, 3);

        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("goto", tokens[0].text, tokens[0].text_length) &&
           ParseIdentifier(tokenizer, &parse_tree->children[1]) &&
           Token_SemiColon == (tokens[1] = GetToken(tokenizer)).type) {
            gs_StringIsEqual("goto", tokens[0].text, tokens[0].text_length) &&
            ParseIdentifier(tokenizer, &parse_tree->children[1]) &&
            Token_SemiColon == (tokens[1] = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Keyword, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1042,8 1042,8 @@ bool ParseJumpStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = at_token;
        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("continue", tokens[0].text, tokens[0].text_length) &&
           Token_SemiColon == (tokens[1] = GetToken(tokenizer)).type) {
            gs_StringIsEqual("continue", tokens[0].text, tokens[0].text_length) &&
            Token_SemiColon == (tokens[1] = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Keyword, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1053,8 1053,8 @@ bool ParseJumpStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = at_token;
        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("break", tokens[0].text, tokens[0].text_length) &&
           Token_SemiColon == (tokens[1] = GetToken(tokenizer)).type) {
            gs_StringIsEqual("break", tokens[0].text, tokens[0].text_length) &&
            Token_SemiColon == (tokens[1] = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Keyword, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1064,7 1064,7 @@ bool ParseJumpStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = at_token;
        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("return", tokens[0].text, tokens[0].text_length)) {
            gs_StringIsEqual("return", tokens[0].text, tokens[0].text_length)) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Keyword, tokens[0]);
                int ChildIndex = 1;
                Tokenizer Previous = *tokenizer;


@@ 1086,9 1086,9 @@ bool ParseJumpStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  iteration-statement:
          while ( expression ) statement
          do statement while ( expression) ;
          for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
  while ( expression ) statement
  do statement while ( expression) ;
  for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
*/
bool ParseIterationStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1099,11 1099,11 @@ bool ParseIterationStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_IterationStatement, 10); /* TODO(AARON): Magic Number! */

        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("while", tokens[0].text, tokens[0].text_length) &&
           Token_OpenParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseExpression(tokenizer, &parse_tree->children[2]) &&
           Token_CloseParen == (tokens[2] = GetToken(tokenizer)).type &&
           ParseStatement(tokenizer, &parse_tree->children[4])) {
            gs_StringIsEqual("while", tokens[0].text, tokens[0].text_length) &&
            Token_OpenParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseExpression(tokenizer, &parse_tree->children[2]) &&
            Token_CloseParen == (tokens[2] = GetToken(tokenizer)).type &&
            ParseStatement(tokenizer, &parse_tree->children[4])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Keyword, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);
                ParseTreeSet(&parse_tree->children[3], ParseTreeNode_Symbol, tokens[2]);


@@ 1114,18 1114,18 @@ bool ParseIterationStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = at_token;
        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("do", tokens[0].text, tokens[0].text_length) &&
           ParseStatement(tokenizer, &parse_tree->children[1])) {
            gs_StringIsEqual("do", tokens[0].text, tokens[0].text_length) &&
            ParseStatement(tokenizer, &parse_tree->children[1])) {
                ParseTreeNode *child_node = &parse_tree->children[0];
                ParseTreeSet(child_node, ParseTreeNode_Keyword, tokens[0]);

                tokens[1] = GetToken(tokenizer);
                if (Token_Keyword == tokens[1].type &&
                   gs_StringIsEqual("while", tokens[1].text, tokens[1].text_length) &&
                   Token_OpenParen == (tokens[2] = GetToken(tokenizer)).type &&
                   ParseExpression(tokenizer, &parse_tree->children[4]) &&
                   Token_CloseParen == (tokens[3] = GetToken(tokenizer)).type &&
                   Token_SemiColon == (tokens[4] = GetToken(tokenizer)).type) {
                    gs_StringIsEqual("while", tokens[1].text, tokens[1].text_length) &&
                    Token_OpenParen == (tokens[2] = GetToken(tokenizer)).type &&
                    ParseExpression(tokenizer, &parse_tree->children[4]) &&
                    Token_CloseParen == (tokens[3] = GetToken(tokenizer)).type &&
                    Token_SemiColon == (tokens[4] = GetToken(tokenizer)).type) {
                        ParseTreeSet(++child_node, ParseTreeNode_Keyword, tokens[1]);
                        ParseTreeSet(++child_node, ParseTreeNode_Symbol, tokens[2]);
                        ++child_node; // Child #4 is set in the `if' above.


@@ 1139,8 1139,8 @@ bool ParseIterationStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = at_token;
        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("for", tokens[0].text, tokens[0].text_length) &&
           Token_OpenParen == (tokens[1] = GetToken(tokenizer)).type) {
            gs_StringIsEqual("for", tokens[0].text, tokens[0].text_length) &&
            Token_OpenParen == (tokens[1] = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Keyword, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);



@@ 1178,7 1178,7 @@ bool ParseIterationStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
                }

                if (Token_CloseParen == (tokens[4] = GetToken(tokenizer)).type &&
                   ParseStatement(tokenizer, &parse_tree->children[i + 1])) {
                    ParseStatement(tokenizer, &parse_tree->children[i + 1])) {
                        ParseTreeSet(&parse_tree->children[i], ParseTreeNode_Symbol, tokens[4]);
                        return true;
                }


@@ 1190,9 1190,9 @@ bool ParseIterationStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  selection-statement:
          if ( expression ) statement
          if ( expression ) statement else statement
          switch ( expression ) statement
  if ( expression ) statement
  if ( expression ) statement else statement
  switch ( expression ) statement
*/
bool ParseSelectionStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1203,11 1203,11 @@ bool ParseSelectionStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_SelectionStatement, 6);

        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("if", tokens[0].text, tokens[0].text_length) &&
           Token_OpenParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseExpression(tokenizer, &parse_tree->children[2]) &&
           Token_CloseParen == (tokens[2] = GetToken(tokenizer)).type &&
           ParseStatement(tokenizer, &parse_tree->children[4])) {
            gs_StringIsEqual("if", tokens[0].text, tokens[0].text_length) &&
            Token_OpenParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseExpression(tokenizer, &parse_tree->children[2]) &&
            Token_CloseParen == (tokens[2] = GetToken(tokenizer)).type &&
            ParseStatement(tokenizer, &parse_tree->children[4])) {
                Tokenizer at_else = *tokenizer;
                Token token = GetToken(tokenizer);



@@ 1216,8 1216,8 @@ bool ParseSelectionStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
                ParseTreeSet(&parse_tree->children[3], ParseTreeNode_Symbol, tokens[2]);

                if (Token_Keyword == token.type &&
                   gs_StringIsEqual("else", token.text, token.text_length) &&
                   ParseStatement(tokenizer, &parse_tree->children[5])) {
                    gs_StringIsEqual("else", token.text, token.text_length) &&
                    ParseStatement(tokenizer, &parse_tree->children[5])) {
                        ParseTreeSet(&parse_tree->children[4], ParseTreeNode_Keyword, token);
                        return true;
                }


@@ 1230,11 1230,11 @@ bool ParseSelectionStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = at_token;
        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("switch", tokens[0].text, tokens[0].text_length) &&
           Token_OpenParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseExpression(tokenizer, &parse_tree->children[2]) &&
           Token_CloseParen == (tokens[2] = GetToken(tokenizer)).type &&
           ParseStatement(tokenizer, &parse_tree->children[4])) {
            gs_StringIsEqual("switch", tokens[0].text, tokens[0].text_length) &&
            Token_OpenParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseExpression(tokenizer, &parse_tree->children[2]) &&
            Token_CloseParen == (tokens[2] = GetToken(tokenizer)).type &&
            ParseStatement(tokenizer, &parse_tree->children[4])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Keyword, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);
                ParseTreeSet(&parse_tree->children[3], ParseTreeNode_Symbol, tokens[2]);


@@ 1251,7 1251,7 @@ bool ParseStatementListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_StatementListI, 2);

        if (ParseStatement(tokenizer, &parse_tree->children[0]) &&
           ParseStatementListI(tokenizer, &parse_tree->children[1])) {
            ParseStatementListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1261,8 1261,8 @@ bool ParseStatementListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  statement-list:
          statement
          statement-list statement
  statement
  statement-list statement
*/
bool ParseStatementList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1270,7 1270,7 @@ bool ParseStatementList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_StatementList, 2);

        if (ParseStatement(tokenizer, &parse_tree->children[0]) &&
           ParseStatementListI(tokenizer, &parse_tree->children[1])) {
            ParseStatementListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1280,7 1280,7 @@ bool ParseStatementList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  compound-statement:
          { declaration-list(opt) statement-list(opt) }
  { declaration-list(opt) statement-list(opt) }
*/
bool ParseCompoundStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1316,7 1316,7 @@ bool ParseCompoundStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  expression-statement:
          expression(opt) ;
  expression(opt) ;
*/
bool ParseExpressionStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1325,7 1325,7 @@ bool ParseExpressionStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ExpressionStatement, 2);

        if (ParseExpression(tokenizer, &parse_tree->children[0]) &&
           Token_SemiColon == (token = GetToken(tokenizer)).type) {
            Token_SemiColon == (token = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 1344,9 1344,9 @@ bool ParseExpressionStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  labeled-statement:
          identifier : statement
          case constant-expression : statement
          default : statement
  identifier : statement
  case constant-expression : statement
  default : statement
*/
bool ParseLabeledStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1355,8 1355,8 @@ bool ParseLabeledStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_LabeledStatement, 4);

        if (ParseIdentifier(tokenizer, &parse_tree->children[0]) &&
           Token_Colon == (tokens[0] = GetToken(tokenizer)).type &&
           ParseStatement(tokenizer, &parse_tree->children[2])) {
            Token_Colon == (tokens[0] = GetToken(tokenizer)).type &&
            ParseStatement(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[0]);
                return true;
        }


@@ 1366,10 1366,10 @@ bool ParseLabeledStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer at_token = *tokenizer;

        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("case", tokens[0].text, tokens[0].text_length) &&
           ParseConstantExpression(tokenizer, &parse_tree->children[1]) &&
           Token_Colon == (tokens[1] = GetToken(tokenizer)).type &&
           ParseStatement(tokenizer, &parse_tree->children[3])) {
            gs_StringIsEqual("case", tokens[0].text, tokens[0].text_length) &&
            ParseConstantExpression(tokenizer, &parse_tree->children[1]) &&
            Token_Colon == (tokens[1] = GetToken(tokenizer)).type &&
            ParseStatement(tokenizer, &parse_tree->children[3])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Keyword, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1379,9 1379,9 @@ bool ParseLabeledStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = at_token;
        if (Token_Keyword == tokens[0].type &&
           gs_StringIsEqual("default", tokens[0].text, tokens[0].text_length) &&
           Token_Colon == (tokens[1] = GetToken(tokenizer)).type &&
           ParseStatement(tokenizer, &parse_tree->children[2])) {
            gs_StringIsEqual("default", tokens[0].text, tokens[0].text_length) &&
            Token_Colon == (tokens[1] = GetToken(tokenizer)).type &&
            ParseStatement(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Keyword, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1393,12 1393,12 @@ bool ParseLabeledStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  statement:
          labeled-statement
          expression-statement
          compound-statement
          selection-statement
          iteration-statement
          jump-statement
  labeled-statement
  expression-statement
  compound-statement
  selection-statement
  iteration-statement
  jump-statement
*/
bool ParseStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1429,7 1429,7 @@ bool ParseStatement(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  typedef-name:
          identifier
  identifier
*/
bool ParseTypedefName(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1449,9 1449,9 @@ bool ParseTypedefName(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  direct-abstract-declarator:
          ( abstract-declarator )
          direct-abstract-declarator(opt) [ constant-expression(opt) ]
          direct-abstract-declarator(opt) ( parameter-type-list(opt) )
  ( abstract-declarator )
  direct-abstract-declarator(opt) [ constant-expression(opt) ]
  direct-abstract-declarator(opt) ( parameter-type-list(opt) )
*/
bool ParseDirectAbstractDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1460,9 1460,9 @@ bool ParseDirectAbstractDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_t
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_DirectAbstractDeclaratorI, 4);

        if (Token_OpenBracket == (tokens[0] = GetToken(tokenizer)).type &&
           ParseConstantExpression(tokenizer, &parse_tree->children[1]) &&
           Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
            ParseConstantExpression(tokenizer, &parse_tree->children[1]) &&
            Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1472,8 1472,8 @@ bool ParseDirectAbstractDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_t

        *tokenizer = start;
        if (Token_OpenBracket == (tokens[0] = GetToken(tokenizer)).type &&
           Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
            Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1481,9 1481,9 @@ bool ParseDirectAbstractDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_t

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           ParseParameterTypeList(tokenizer, &parse_tree->children[1]) &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[3])) {
            ParseParameterTypeList(tokenizer, &parse_tree->children[1]) &&
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[3])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1493,8 1493,8 @@ bool ParseDirectAbstractDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_t

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1506,9 1506,9 @@ bool ParseDirectAbstractDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_t

/*
  direct-abstract-declarator:
          ( abstract-declarator )
          direct-abstract-declarator(opt) [ constant-expression(opt) ]
          direct-abstract-declarator(opt) ( parameter-type-list(opt) )
  ( abstract-declarator )
  direct-abstract-declarator(opt) [ constant-expression(opt) ]
  direct-abstract-declarator(opt) ( parameter-type-list(opt) )
*/
bool ParseDirectAbstractDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1517,9 1517,9 @@ bool ParseDirectAbstractDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tr
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_DirectAbstractDeclarator, 4);

        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           ParseAbstractDeclarator(tokenizer, &parse_tree->children[1]) &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[3])) {
            ParseAbstractDeclarator(tokenizer, &parse_tree->children[1]) &&
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[3])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1527,9 1527,9 @@ bool ParseDirectAbstractDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tr

        *tokenizer = start;
        if (Token_OpenBracket == (tokens[0] = GetToken(tokenizer)).type &&
           ParseConstantExpression(tokenizer, &parse_tree->children[1]) &&
           Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[3])) {
            ParseConstantExpression(tokenizer, &parse_tree->children[1]) &&
            Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[3])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1539,8 1539,8 @@ bool ParseDirectAbstractDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tr

        *tokenizer = start;
        if (Token_OpenBracket == (tokens[0] = GetToken(tokenizer)).type &&
           Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
            Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1548,9 1548,9 @@ bool ParseDirectAbstractDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tr

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           ParseParameterTypeList(tokenizer, &parse_tree->children[1]) &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
            ParseParameterTypeList(tokenizer, &parse_tree->children[1]) &&
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1558,8 1558,8 @@ bool ParseDirectAbstractDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tr

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectAbstractDeclaratorI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1571,8 1571,8 @@ bool ParseDirectAbstractDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tr

/*
  abstract-declarator:
          pointer
          pointer(opt) direct-abstract-declarator
  pointer
  pointer(opt) direct-abstract-declarator
*/
bool ParseAbstractDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1580,7 1580,7 @@ bool ParseAbstractDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_AbstractDeclarator, 2);

        if (ParsePointer(tokenizer, &parse_tree->children[0]) &&
           ParseDirectAbstractDeclarator(tokenizer, &parse_tree->children[1])) {
            ParseDirectAbstractDeclarator(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1602,7 1602,7 @@ bool ParseAbstractDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  type-name:
          specifier-qualifier-list abstract-declarator(opt)
  specifier-qualifier-list abstract-declarator(opt)
*/
bool ParseTypeName(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1610,7 1610,7 @@ bool ParseTypeName(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_TypeName, 2);

        if (ParseSpecifierQualifierList(tokenizer, &parse_tree->children[0]) &&
           ParseAbstractDeclarator(tokenizer, &parse_tree->children[1])) {
            ParseAbstractDeclarator(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1632,8 1632,8 @@ bool ParseInitializerListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_InitializerListI, 3);

        if (Token_Comma == (token = GetToken(tokenizer)).type &&
           ParseInitializer(tokenizer, &parse_tree->children[1]) &&
           ParseInitializerListI(tokenizer, &parse_tree->children[2])) {
            ParseInitializer(tokenizer, &parse_tree->children[1]) &&
            ParseInitializerListI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 1644,8 1644,8 @@ bool ParseInitializerListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  initializer-list:
          initializer
          initializer-list , initializer
  initializer
  initializer-list , initializer
*/
bool ParseInitializerList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1653,7 1653,7 @@ bool ParseInitializerList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_InitializerList, 2);

        if (ParseInitializer(tokenizer, &parse_tree->children[0]) &&
           ParseInitializerListI(tokenizer, &parse_tree->children[1])) {
            ParseInitializerListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1663,9 1663,9 @@ bool ParseInitializerList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  initializer:
          assignment-expression
          { initializer-list }
          { initializer-list , }
  assignment-expression
  { initializer-list }
  { initializer-list , }
*/
bool ParseInitializer(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1679,8 1679,8 @@ bool ParseInitializer(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_OpenBrace == (tokens[0] = GetToken(tokenizer)).type &&
           ParseInitializerList(tokenizer, &parse_tree->children[1]) &&
           Token_CloseBrace == (tokens[1] = GetToken(tokenizer)).type) {
            ParseInitializerList(tokenizer, &parse_tree->children[1]) &&
            Token_CloseBrace == (tokens[1] = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1688,9 1688,9 @@ bool ParseInitializer(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_OpenBrace == (tokens[0] = GetToken(tokenizer)).type &&
           ParseInitializerList(tokenizer, &parse_tree->children[1]) &&
           Token_Comma == (tokens[1] = GetToken(tokenizer)).type &&
           Token_CloseBrace == (tokens[2] = GetToken(tokenizer)).type) {
            ParseInitializerList(tokenizer, &parse_tree->children[1]) &&
            Token_Comma == (tokens[1] = GetToken(tokenizer)).type &&
            Token_CloseBrace == (tokens[2] = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                ParseTreeSet(&parse_tree->children[3], ParseTreeNode_Symbol, tokens[2]);


@@ 1708,8 1708,8 @@ bool ParseIdentifierListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_IdentifierListI, 3);

        if (Token_Comma == (token = GetToken(tokenizer)).type &&
           ParseIdentifier(tokenizer, &parse_tree->children[1]) &&
           ParseIdentifierListI(tokenizer, &parse_tree->children[2])) {
            ParseIdentifier(tokenizer, &parse_tree->children[1]) &&
            ParseIdentifierListI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 1720,8 1720,8 @@ bool ParseIdentifierListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  identifier-list:
          identifier
          identifier-list , identifier
  identifier
  identifier-list , identifier
*/
bool ParseIdentifierList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1729,7 1729,7 @@ bool ParseIdentifierList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_IdentifierList, 2);

        if (ParseIdentifier(tokenizer, &parse_tree->children[0]) &&
           ParseIdentifierListI(tokenizer, &parse_tree->children[1])) {
            ParseIdentifierListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1739,8 1739,8 @@ bool ParseIdentifierList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  parameter-declaration:
          declaration-specifiers declarator
          declaration-specifiers abstract-declarator(opt)
  declaration-specifiers declarator
  declaration-specifiers abstract-declarator(opt)
*/
bool ParseParameterDeclaration(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1748,13 1748,13 @@ bool ParseParameterDeclaration(Tokenizer *tokenizer, ParseTreeNode *parse_tree) 
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ParameterDeclaration, 2);

        if (ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[0]) &&
           ParseDeclarator(tokenizer, &parse_tree->children[1])) {
            ParseDeclarator(tokenizer, &parse_tree->children[1])) {
                return true;
        }

        *tokenizer = start;
        if (ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[0]) &&
           ParseAbstractDeclarator(tokenizer, &parse_tree->children[1])) {
            ParseAbstractDeclarator(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1776,8 1776,8 @@ bool ParseParameterListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ParameterListI, 3);

        if (Token_Comma == (token = GetToken(tokenizer)).type &&
           ParseParameterDeclaration(tokenizer, &parse_tree->children[1]) &&
           ParseParameterListI(tokenizer, &parse_tree->children[2])) {
            ParseParameterDeclaration(tokenizer, &parse_tree->children[1]) &&
            ParseParameterListI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 1788,8 1788,8 @@ bool ParseParameterListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  parameter-list:
          parameter-declaration
          parameter-list , parameter-declaration
  parameter-declaration
  parameter-list , parameter-declaration
*/
bool ParseParameterList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1797,7 1797,7 @@ bool ParseParameterList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_ParameterList, 2);

        if (ParseParameterDeclaration(tokenizer, &parse_tree->children[0]) &&
           ParseParameterListI(tokenizer, &parse_tree->children[1])) {
            ParseParameterListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1807,8 1807,8 @@ bool ParseParameterList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  parameter-type-list:
          parameter-list
          parameter-list , ...
  parameter-list
  parameter-list , ...
*/
bool ParseParameterTypeList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1819,7 1819,7 @@ bool ParseParameterTypeList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        if (ParseParameterList(tokenizer, &parse_tree->children[0])) {
                Tokenizer Previous = *tokenizer;
                if (Token_Comma == (tokens[0] = GetToken(tokenizer)).type &&
                   Token_Ellipsis == (tokens[1] = GetToken(tokenizer)).type) {
                    Token_Ellipsis == (tokens[1] = GetToken(tokenizer)).type) {
                        ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[0]);
                        ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                        return true;


@@ 1839,7 1839,7 @@ bool ParseTypeQualifierListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_TypeQualifierListI, 2);

        if (ParseTypeQualifier(tokenizer, &parse_tree->children[0]) &&
           ParseTypeQualifierListI(tokenizer, &parse_tree->children[1])) {
            ParseTypeQualifierListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1849,8 1849,8 @@ bool ParseTypeQualifierListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  type-qualifier-list:
          type-qualifier
          type-qualifier-list type-qualifier
  type-qualifier
  type-qualifier-list type-qualifier
*/
bool ParseTypeQualifierList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1858,7 1858,7 @@ bool ParseTypeQualifierList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_TypeQualifierList, 2);

        if (ParseTypeQualifier(tokenizer, &parse_tree->children[0]) &&
           ParseTypeQualifierListI(tokenizer, &parse_tree->children[1])) {
            ParseTypeQualifierListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1868,8 1868,8 @@ bool ParseTypeQualifierList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  pointer:
          * type-qualifier-list(opt)
          * type-qualifier-list(opt) pointer
  * type-qualifier-list(opt)
  * type-qualifier-list(opt) pointer
  */
bool ParsePointer(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1886,7 1886,7 @@ bool ParsePointer(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        ParseTreeSet(parse_tree, ParseTreeNode_Pointer, token);

        if (ParseTypeQualifierList(tokenizer, &parse_tree->children[0]) &&
           ParsePointer(tokenizer, &parse_tree->children[1])) {
            ParsePointer(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 1908,11 1908,11 @@ bool ParsePointer(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  direct-declarator:
          identifier
          ( declarator )
          direct-declarator [ constant-expression(opt) ]
          direct-declarator ( parameter-type-list )
          direct-declarator ( identifier-list(opt) )
  identifier
  ( declarator )
  direct-declarator [ constant-expression(opt) ]
  direct-declarator ( parameter-type-list )
  direct-declarator ( identifier-list(opt) )
*/
bool ParseDirectDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1921,9 1921,9 @@ bool ParseDirectDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_DirectDeclaratorI, 4);

        if (Token_OpenBracket == (tokens[0] = GetToken(tokenizer)).type &&
           ParseConstantExpression(tokenizer, &parse_tree->children[1]) &&
           Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectDeclaratorI(tokenizer, &parse_tree->children[3])) {
            ParseConstantExpression(tokenizer, &parse_tree->children[1]) &&
            Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectDeclaratorI(tokenizer, &parse_tree->children[3])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1933,8 1933,8 @@ bool ParseDirectDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_OpenBracket == (tokens[0] = GetToken(tokenizer)).type &&
           Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectDeclaratorI(tokenizer, &parse_tree->children[2])) {
            Token_CloseBracket == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectDeclaratorI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1942,9 1942,9 @@ bool ParseDirectDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           ParseParameterTypeList(tokenizer, &parse_tree->children[1]) &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectDeclaratorI(tokenizer, &parse_tree->children[3])) {
            ParseParameterTypeList(tokenizer, &parse_tree->children[1]) &&
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectDeclaratorI(tokenizer, &parse_tree->children[3])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1952,9 1952,9 @@ bool ParseDirectDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           ParseIdentifierList(tokenizer, &parse_tree->children[1]) &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectDeclaratorI(tokenizer, &parse_tree->children[3])) {
            ParseIdentifierList(tokenizer, &parse_tree->children[1]) &&
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectDeclaratorI(tokenizer, &parse_tree->children[3])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1964,8 1964,8 @@ bool ParseDirectDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectDeclaratorI(tokenizer, &parse_tree->children[2])) {
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectDeclaratorI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 1977,11 1977,11 @@ bool ParseDirectDeclaratorI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  direct-declarator:
          identifier
          ( declarator )
          direct-declarator [ constant-expression(opt) ]
          direct-declarator ( parameter-type-list )
          direct-declarator ( identifier-list(opt) )
  identifier
  ( declarator )
  direct-declarator [ constant-expression(opt) ]
  direct-declarator ( parameter-type-list )
  direct-declarator ( identifier-list(opt) )
*/
bool ParseDirectDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 1990,15 1990,15 @@ bool ParseDirectDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_DirectDeclarator, 4);

        if (ParseIdentifier(tokenizer, &parse_tree->children[0]) &&
           ParseDirectDeclaratorI(tokenizer, &parse_tree->children[1])) {
            ParseDirectDeclaratorI(tokenizer, &parse_tree->children[1])) {
                return true;
        }

        *tokenizer = start;
        if (Token_OpenParen == (tokens[0] = GetToken(tokenizer)).type &&
           ParseDeclarator(tokenizer, &parse_tree->children[1]) &&
           Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
           ParseDirectDeclaratorI(tokenizer, &parse_tree->children[3])) {
            ParseDeclarator(tokenizer, &parse_tree->children[1]) &&
            Token_CloseParen == (tokens[1] = GetToken(tokenizer)).type &&
            ParseDirectDeclaratorI(tokenizer, &parse_tree->children[3])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 2010,7 2010,7 @@ bool ParseDirectDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  declarator:
          pointer(opt) direct-declarator
  pointer(opt) direct-declarator
*/
bool ParseDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2018,7 2018,7 @@ bool ParseDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_Declarator, 2);

        if (ParsePointer(tokenizer, &parse_tree->children[0]) &&
           ParseDirectDeclarator(tokenizer, &parse_tree->children[1])) {
            ParseDirectDeclarator(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2035,8 2035,8 @@ bool ParseDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  enumerator:
          identifier
          identifier = constant-expression
  identifier
  identifier = constant-expression
*/
bool ParseEnumerator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2045,8 2045,8 @@ bool ParseEnumerator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_Enumerator, 3);

        if (ParseIdentifier(tokenizer, &parse_tree->children[0]) &&
           Token_EqualSign == (token = GetToken(tokenizer)).type &&
           ParseConstantExpression(tokenizer, &parse_tree->children[2])) {
            Token_EqualSign == (token = GetToken(tokenizer)).type &&
            ParseConstantExpression(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 2069,8 2069,8 @@ bool ParseEnumeratorListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_EnumeratorListI, 3);

        if (Token_Comma == (token = GetToken(tokenizer)).type &&
           ParseEnumerator(tokenizer, &parse_tree->children[1]) &&
           ParseEnumeratorListI(tokenizer, &parse_tree->children[2])) {
            ParseEnumerator(tokenizer, &parse_tree->children[1]) &&
            ParseEnumeratorListI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 2081,8 2081,8 @@ bool ParseEnumeratorListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  enumerator-list:
          enumerator
          enumerator-list , enumerator
  enumerator
  enumerator-list , enumerator
*/
bool ParseEnumeratorList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2090,7 2090,7 @@ bool ParseEnumeratorList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_EnumeratorList, 2);

        if (ParseEnumerator(tokenizer, &parse_tree->children[0]) &&
           ParseEnumeratorListI(tokenizer, &parse_tree->children[1])) {
            ParseEnumeratorListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2100,8 2100,8 @@ bool ParseEnumeratorList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  enum-specifier:
          enum identifier(opt) { enumerator-list }
          enum identifier
  enum identifier(opt) { enumerator-list }
  enum identifier
*/
bool ParseEnumSpecifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2112,7 2112,7 @@ bool ParseEnumSpecifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_EnumSpecifier, 5);

        if (!(Token_Keyword == token.type &&
             gs_StringIsEqual("enum", token.text, token.text_length))) {
              gs_StringIsEqual("enum", token.text, token.text_length))) {
                *tokenizer = start;
                return false;
        }


@@ 2120,9 2120,9 @@ bool ParseEnumSpecifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Keyword, token);

        if (ParseIdentifier(tokenizer, &parse_tree->children[1]) &&
           Token_OpenBrace == (tokens[0] = GetToken(tokenizer)).type &&
           ParseEnumeratorList(tokenizer, &parse_tree->children[3]) &&
           Token_CloseBrace == (tokens[1] = GetToken(tokenizer)).type) {
            Token_OpenBrace == (tokens[0] = GetToken(tokenizer)).type &&
            ParseEnumeratorList(tokenizer, &parse_tree->children[3]) &&
            Token_CloseBrace == (tokens[1] = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[4], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 2133,8 2133,8 @@ bool ParseEnumSpecifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = at_token;
        if (Token_OpenBrace == (tokens[0] = GetToken(tokenizer)).type &&
           ParseEnumeratorList(tokenizer, &parse_tree->children[2]) &&
           Token_CloseBrace == (tokens[1] = GetToken(tokenizer)).type) {
            ParseEnumeratorList(tokenizer, &parse_tree->children[2]) &&
            Token_CloseBrace == (tokens[1] = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[3], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 2153,8 2153,8 @@ bool ParseEnumSpecifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  struct-declarator:
          declarator
          declarator(opt) : constant-expression
  declarator
  declarator(opt) : constant-expression
*/
bool ParseStructDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2163,8 2163,8 @@ bool ParseStructDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_StructDeclarator, 3);

        if (ParseDeclarator(tokenizer, &parse_tree->children[0]) &&
           Token_Colon == (token = GetToken(tokenizer)).type &&
           ParseConstantExpression(tokenizer, &parse_tree->children[2])) {
            Token_Colon == (token = GetToken(tokenizer)).type &&
            ParseConstantExpression(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 2173,7 2173,7 @@ bool ParseStructDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (Token_Colon == (token = GetToken(tokenizer)).type &&
           ParseConstantExpression(tokenizer, &parse_tree->children[1])) {
            ParseConstantExpression(tokenizer, &parse_tree->children[1])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 2196,8 2196,8 @@ bool ParseStructDeclaratorListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree)
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_StructDeclaratorListI, 3);

        if (Token_Comma == (token = GetToken(tokenizer)).type &&
           ParseStructDeclarator(tokenizer, &parse_tree->children[1]) &&
           ParseStructDeclaratorListI(tokenizer, &parse_tree->children[2])) {
            ParseStructDeclarator(tokenizer, &parse_tree->children[1]) &&
            ParseStructDeclaratorListI(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 2208,8 2208,8 @@ bool ParseStructDeclaratorListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree)

/*
  struct-declarator-list:
          struct-declarator
          struct-declarator-list , struct-declarator
  struct-declarator
  struct-declarator-list , struct-declarator
*/
bool ParseStructDeclaratorList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2217,7 2217,7 @@ bool ParseStructDeclaratorList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) 
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_StructDeclaratorList, 2);

        if (ParseStructDeclarator(tokenizer, &parse_tree->children[0]) &&
           ParseStructDeclaratorListI(tokenizer, &parse_tree->children[1])) {
            ParseStructDeclaratorListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2227,8 2227,8 @@ bool ParseStructDeclaratorList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) 

/*
  specifier-qualifier-list:
          type-specifier specifier-qualifier-list(opt)
          type-qualifier specifier-qualifier-list(opt)
  type-specifier specifier-qualifier-list(opt)
  type-qualifier specifier-qualifier-list(opt)
*/
bool ParseSpecifierQualifierList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2236,7 2236,7 @@ bool ParseSpecifierQualifierList(Tokenizer *tokenizer, ParseTreeNode *parse_tree
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_SpecifierQualifierList, 2);

        if (ParseTypeSpecifier(tokenizer, &parse_tree->children[0]) &&
           ParseSpecifierQualifierList(tokenizer, &parse_tree->children[1])) {
            ParseSpecifierQualifierList(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2249,7 2249,7 @@ bool ParseSpecifierQualifierList(Tokenizer *tokenizer, ParseTreeNode *parse_tree

        *tokenizer = start;
        if (ParseTypeQualifier(tokenizer, &parse_tree->children[0]) &&
           ParseSpecifierQualifierList(tokenizer, &parse_tree->children[1])) {
            ParseSpecifierQualifierList(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2266,7 2266,7 @@ bool ParseSpecifierQualifierList(Tokenizer *tokenizer, ParseTreeNode *parse_tree

/*
  struct-declaration:
          specifier-qualifier-list struct-declarator-list ;
  specifier-qualifier-list struct-declarator-list ;
*/
bool ParseStructDeclaration(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2275,8 2275,8 @@ bool ParseStructDeclaration(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_StructDeclaration, 3);

        if (ParseSpecifierQualifierList(tokenizer, &parse_tree->children[0]) &&
           ParseStructDeclaratorList(tokenizer, &parse_tree->children[1]) &&
           Token_SemiColon == (token = GetToken(tokenizer)).type) {
            ParseStructDeclaratorList(tokenizer, &parse_tree->children[1]) &&
            Token_SemiColon == (token = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_StructDeclaration, token);
                return true;
        }


@@ 2287,8 2287,8 @@ bool ParseStructDeclaration(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  init-declarator:
          declarator
          declarator = initializer
  declarator
  declarator = initializer
*/
bool ParseInitDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2297,8 2297,8 @@ bool ParseInitDeclarator(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_InitDeclarator, 3);

        if (ParseDeclarator(tokenizer, &parse_tree->children[0]) &&
           Token_EqualSign == (token = GetToken(tokenizer)).type &&
           ParseInitializer(tokenizer, &parse_tree->children[2])) {
            Token_EqualSign == (token = GetToken(tokenizer)).type &&
            ParseInitializer(tokenizer, &parse_tree->children[2])) {
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 2321,7 2321,7 @@ bool ParseInitDeclaratorListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_InitDeclaratorListI, 2);

        if (Token_Comma == (token = GetToken(tokenizer)).type &&
           ParseInitDeclarator(tokenizer, &parse_tree->children[1])) {
            ParseInitDeclarator(tokenizer, &parse_tree->children[1])) {
                ParseTreeSet(&parse_tree->children[0], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 2332,8 2332,8 @@ bool ParseInitDeclaratorListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  init-declarator-list:
          init-declarator
          init-declarator-list , init-declarator
  init-declarator
  init-declarator-list , init-declarator
*/
bool ParseInitDeclaratorList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2341,7 2341,7 @@ bool ParseInitDeclaratorList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_InitDeclarationList, 2);

        if (ParseInitDeclarator(tokenizer, &parse_tree->children[0]) &&
           ParseInitDeclaratorListI(tokenizer, &parse_tree->children[1])) {
            ParseInitDeclaratorListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2355,7 2355,7 @@ bool ParseStructDeclarationListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_StructDeclarationListI, 2);

        if (ParseStructDeclaration(tokenizer, &parse_tree->children[0]) &&
           ParseStructDeclarationListI(tokenizer, &parse_tree->children[1])) {
            ParseStructDeclarationListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2365,8 2365,8 @@ bool ParseStructDeclarationListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree

/*
  struct-declaration-list:
          struct-declaration
          struct-declaration-list struct-declaration
  struct-declaration
  struct-declaration-list struct-declaration
*/
bool ParseStructDeclarationList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2374,7 2374,7 @@ bool ParseStructDeclarationList(Tokenizer *tokenizer, ParseTreeNode *parse_tree)
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_StructDeclarationList, 2);

        if (ParseStructDeclaration(tokenizer, &parse_tree->children[0]) &&
           ParseStructDeclarationListI(tokenizer, &parse_tree->children[1])) {
            ParseStructDeclarationListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2392,7 2392,7 @@ bool ParseStructOrUnion(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        if (Token_Keyword == token.type) {
                if (gs_StringIsEqual(token.text, "struct", token.text_length) ||
                   gs_StringIsEqual(token.text, "union", token.text_length)) {
                    gs_StringIsEqual(token.text, "union", token.text_length)) {
                        ParseTreeSet(parse_tree, ParseTreeNode_StructOrUnion, token);
                        return true;
                }


@@ 2404,8 2404,8 @@ bool ParseStructOrUnion(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  struct-or-union-specifier:
          struct-or-union identifier(opt) { struct-declaration-list }
          struct-or-union identifier
  struct-or-union identifier(opt) { struct-declaration-list }
  struct-or-union identifier
*/
bool ParseStructOrUnionSpecifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2415,10 2415,10 @@ bool ParseStructOrUnionSpecifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree
        Token tokens[2];

        if (ParseStructOrUnion(tokenizer, &parse_tree->children[0]) &&
           ParseIdentifier(tokenizer, &parse_tree->children[1]) &&
           Token_OpenBrace == (tokens[0] = GetToken(tokenizer)).type &&
           ParseStructDeclarationList(tokenizer, &parse_tree->children[3]) &&
           Token_CloseBrace == (tokens[1] = GetToken(tokenizer)).type) {
            ParseIdentifier(tokenizer, &parse_tree->children[1]) &&
            Token_OpenBrace == (tokens[0] = GetToken(tokenizer)).type &&
            ParseStructDeclarationList(tokenizer, &parse_tree->children[3]) &&
            Token_CloseBrace == (tokens[1] = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[4], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 2428,9 2428,9 @@ bool ParseStructOrUnionSpecifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree

        *tokenizer = start;
        if (ParseStructOrUnion(tokenizer, &parse_tree->children[0]) &&
           Token_OpenBrace == (tokens[0] = GetToken(tokenizer)).type &&
           ParseStructDeclarationList(tokenizer, &parse_tree->children[2]) &&
           Token_CloseBrace == (tokens[1] = GetToken(tokenizer)).type) {
            Token_OpenBrace == (tokens[0] = GetToken(tokenizer)).type &&
            ParseStructDeclarationList(tokenizer, &parse_tree->children[2]) &&
            Token_CloseBrace == (tokens[1] = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, tokens[0]);
                ParseTreeSet(&parse_tree->children[3], ParseTreeNode_Symbol, tokens[1]);
                return true;


@@ 2440,7 2440,7 @@ bool ParseStructOrUnionSpecifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree

        *tokenizer = start;
        if (ParseStructOrUnion(tokenizer, &parse_tree->children[0]) &&
           ParseIdentifier(tokenizer, &parse_tree->children[1])) {
            ParseIdentifier(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2458,7 2458,7 @@ bool ParseTypeQualifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        if (token.type == Token_Keyword) {
                if (gs_StringIsEqual(token.text, "const", token.text_length) ||
                   gs_StringIsEqual(token.text, "volatile", token.text_length)) {
                    gs_StringIsEqual(token.text, "volatile", token.text_length)) {
                        ParseTreeSet(parse_tree, ParseTreeNode_TypeQualifier, token);
                        return true;
                }


@@ 2534,9 2534,9 @@ bool ParseStorageClassSpecifier(Tokenizer *tokenizer, ParseTreeNode *parse_tree)

/*
  declaration-specifiers:
          storage-class-specifier declaration-specifiers(opt)
          type-specifier declaration-specifiers(opt)
          type-qualifier declaration-specifiers(opt)
  storage-class-specifier declaration-specifiers(opt)
  type-specifier declaration-specifiers(opt)
  type-qualifier declaration-specifiers(opt)
*/
bool ParseDeclarationSpecifiers(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2544,19 2544,19 @@ bool ParseDeclarationSpecifiers(Tokenizer *tokenizer, ParseTreeNode *parse_tree)
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_DeclarationSpecifiers, 2);

        if (ParseStorageClassSpecifier(tokenizer, &parse_tree->children[0]) &&
           ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[1])) {
            ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[1])) {
                return true;
        }

        *tokenizer = start;
        if (ParseTypeSpecifier(tokenizer, &parse_tree->children[0]) &&
           ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[1])) {
            ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[1])) {
                return true;
        }

        *tokenizer = start;
        if (ParseTypeQualifier(tokenizer, &parse_tree->children[0]) &&
           ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[1])) {
            ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2587,7 2587,7 @@ bool ParseDeclarationListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_DeclarationListI, 2);

        if (ParseDeclaration(tokenizer, &parse_tree->children[0]) &&
           ParseDeclarationListI(tokenizer, &parse_tree->children[1])) {
            ParseDeclarationListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2597,8 2597,8 @@ bool ParseDeclarationListI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  declaration-list:
          declaration
          declaration-list declaration
  declaration
  declaration-list declaration
*/
bool ParseDeclarationList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2606,7 2606,7 @@ bool ParseDeclarationList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_DeclarationList, 2);

        if (ParseDeclaration(tokenizer, &parse_tree->children[0]) &&
           ParseDeclarationListI(tokenizer, &parse_tree->children[1])) {
            ParseDeclarationListI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2616,7 2616,7 @@ bool ParseDeclarationList(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  declaration:
          declaration-specifiers init-declarator-list(opt) ;
  declaration-specifiers init-declarator-list(opt) ;
*/
bool ParseDeclaration(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2625,15 2625,15 @@ bool ParseDeclaration(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_Declaration, 3);

        if (ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[0]) &&
           ParseInitDeclaratorList(tokenizer, &parse_tree->children[1]) &&
           Token_SemiColon == (token = GetToken(tokenizer)).type) {
            ParseInitDeclaratorList(tokenizer, &parse_tree->children[1]) &&
            Token_SemiColon == (token = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[2], ParseTreeNode_Symbol, token);
                return true;
        }

        *tokenizer = start;
        if (ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[0]) &&
           Token_SemiColon == (token = GetToken(tokenizer)).type) {
            Token_SemiColon == (token = GetToken(tokenizer)).type) {
                ParseTreeSet(&parse_tree->children[1], ParseTreeNode_Symbol, token);
                return true;
        }


@@ 2644,7 2644,7 @@ bool ParseDeclaration(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  function-definition:
          declaration-specifiers(opt) declarator declaration-list(opt) compound-statement
  declaration-specifiers(opt) declarator declaration-list(opt) compound-statement
*/
bool ParseFunctionDefinition(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2652,9 2652,9 @@ bool ParseFunctionDefinition(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_FunctionDefinition, 4);

        if (ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[0]) &&
           ParseDeclarator(tokenizer, &parse_tree->children[1]) &&
           ParseDeclarationList(tokenizer, &parse_tree->children[2]) &&
           ParseCompoundStatement(tokenizer, &parse_tree->children[3])) {
            ParseDeclarator(tokenizer, &parse_tree->children[1]) &&
            ParseDeclarationList(tokenizer, &parse_tree->children[2]) &&
            ParseCompoundStatement(tokenizer, &parse_tree->children[3])) {
                return true;
        }



@@ 2662,15 2662,15 @@ bool ParseFunctionDefinition(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (ParseDeclarationSpecifiers(tokenizer, &parse_tree->children[0]) &&
           ParseDeclarator(tokenizer, &parse_tree->children[1]) &&
           ParseCompoundStatement(tokenizer, &parse_tree->children[2])) {
            ParseDeclarator(tokenizer, &parse_tree->children[1]) &&
            ParseCompoundStatement(tokenizer, &parse_tree->children[2])) {
                return true;
        }

        *tokenizer = start;
        if (ParseDeclarator(tokenizer, &parse_tree->children[0]) &&
           ParseDeclarationList(tokenizer, &parse_tree->children[1]) &&
           ParseCompoundStatement(tokenizer, &parse_tree->children[2])) {
            ParseDeclarationList(tokenizer, &parse_tree->children[1]) &&
            ParseCompoundStatement(tokenizer, &parse_tree->children[2])) {
                return true;
        }



@@ 2678,7 2678,7 @@ bool ParseFunctionDefinition(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

        *tokenizer = start;
        if (ParseDeclarator(tokenizer, &parse_tree->children[0]) &&
           ParseCompoundStatement(tokenizer, &parse_tree->children[1])) {
            ParseCompoundStatement(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2688,8 2688,8 @@ bool ParseFunctionDefinition(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  external-declaration:
          function-definition
          declaration
  function-definition
  declaration
*/
bool ParseExternalDeclaration(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2711,7 2711,7 @@ bool ParseTranslationUnitI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_TranslationUnitI, 2);

        if (ParseExternalDeclaration(tokenizer, &parse_tree->children[0]) &&
           ParseTranslationUnitI(tokenizer, &parse_tree->children[1])) {
            ParseTranslationUnitI(tokenizer, &parse_tree->children[1])) {
                return true;
        }



@@ 2721,8 2721,8 @@ bool ParseTranslationUnitI(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {

/*
  translation-unit:
          external-declaration
          translation-unit external-declaration
  external-declaration
  translation-unit external-declaration
*/
bool ParseTranslationUnit(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        Tokenizer start = *tokenizer;


@@ 2730,7 2730,7 @@ bool ParseTranslationUnit(Tokenizer *tokenizer, ParseTreeNode *parse_tree) {
        __parser_ParseTreeUpdate(parse_tree, ParseTreeNode_TranslationUnit, 2);

        if (ParseExternalDeclaration(tokenizer, &parse_tree->children[0]) &&
           ParseTranslationUnitI(tokenizer, &parse_tree->children[1])) {
            ParseTranslationUnitI(tokenizer, &parse_tree->children[1])) {
                return true;
        }