Ignore:
Timestamp:
Aug 10, 2016, 2:29:44 PM (9 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
be0a9d8, ef42e764
Parents:
f18a711 (diff), a563f01 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/parser.yy

    rf18a711 r3078643  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 08:15:57 2016
    13 // Update Count     : 1721
     12// Last Modified On : Wed Aug 10 13:09:53 2016
     13// Update Count     : 1844
    1414//
    1515
    … …  
    6060std::stack< LinkageSpec::Type > linkageStack;
    6161TypedefTable typedefTable;
     62
     63void appendStr( std::string &to, std::string *from ) {
     64        // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
     65        to.insert( to.length() - 1, from->substr( 1, from->length() - 2 ) );
     66} // appendStr
    6267%}
    6368
    … …  
    116121        DeclarationNode::TypeClass tclass;
    117122        StatementNode *sn;
    118         ConstantNode *constant;
     123        ConstantExpr *constant;
     124        ForCtl *fctl;
    119125        LabelNode *label;
    120126        InitializerNode *in;
    121         OperatorNode::Type op;
     127        OperKinds op;
    122128        bool flag;
    123129}
    … …  
    128134
    129135// expressions
    130 %type<constant> constant
     136%type<en> constant
    131137%type<en> tuple                                                 tuple_expression_list
    132 %type<op> ptrref_operator
    133 %type<en> unary_operator                                assignment_operator
     138%type<op> ptrref_operator                               unary_operator                          assignment_operator
    134139%type<en> primary_expression                    postfix_expression                      unary_expression
    135140%type<en> cast_expression                               multiplicative_expression       additive_expression                     shift_expression
    … …  
    138143%type<en> constant_expression                   assignment_expression           assignment_expression_opt
    139144%type<en> comma_expression                              comma_expression_opt
    140 %type<en> argument_expression_list              argument_expression                     for_control_expression          assignment_opt
     145//%type<en> argument_expression_list            argument_expression                     for_control_expression          assignment_opt
     146%type<en> argument_expression_list              argument_expression                     assignment_opt
     147%type<fctl> for_control_expression
    141148%type<en> subrange
    142149%type<en> asm_operands_opt asm_operands_list asm_operand
    143150%type<label> label_list
    144 %type<constant> asm_clobbers_list_opt
     151%type<en> asm_clobbers_list_opt
    145152%type<flag> asm_volatile_opt
    146153
    … …  
    305312constant:
    306313                // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
    307 INTEGERconstant                                                                 { $$ = makeConstantInteger( *$1 ); }
    308         | FLOATINGconstant                                                      { $$ = makeConstantFloat( *$1 ); }
    309         | CHARACTERconstant                                                     { $$ = makeConstantChar( *$1 ); }
     314INTEGERconstant                                                                 { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
     315        | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
     316        | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( *$1 ) ); }
    310317        ;
    311318
    … …  
    332339
    333340string_literal_list:                                                                    // juxtaposed strings are concatenated
    334         STRINGliteral                                                           { $$ = makeConstantStr( *$1 ); }
    335         | string_literal_list STRINGliteral                     { $$ = $1->appendstr( $2 ); }
     341        STRINGliteral                                                           { $$ = build_constantStr( *$1 ); }
     342        | string_literal_list STRINGliteral
     343                {
     344                        appendStr( $1->get_constant()->get_value(), $2 );
     345                        delete $2;                                                                      // allocated by lexer
     346                        $$ = $1;
     347                }
    336348        ;
    337349
    … …  
    340352primary_expression:
    341353        IDENTIFIER                                                                                      // typedef name cannot be used as a variable name
    342                 { $$ = new VarRefNode( $1 ); }
     354                { $$ = new ExpressionNode( build_varref( $1 ) ); }
    343355        | zero_one
    344                 { $$ = new VarRefNode( $1 ); }
     356                { $$ = new ExpressionNode( build_varref( $1 ) ); }
    345357        | '(' comma_expression ')'
    346358                { $$ = $2; }
    347359        | '(' compound_statement ')'                                            // GCC, lambda expression
    348                 { $$ = new ValofExprNode( $2 ); }
     360        { $$ = new ExpressionNode( build_valexpr( $2 ) ); }
    349361        ;
    350362
    … …  
    356368                // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
    357369                // equivalent to the old x[i,j].
    358                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Index, $1, $4 ) ); }
     370                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $4 ) ); }
    359371        | postfix_expression '(' argument_expression_list ')'
    360                 { $$ = new CompositeExprNode( $1, $3 ); }
     372                { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
    361373        // ambiguity with .0 so space required after field-selection, e.g.
    362374                //   struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1;
    363375        | postfix_expression '.' no_attr_identifier
    364                 { $$ = new CompositeExprNode2( build_fieldSel( $1, new VarRefNode( $3 ) ) ); }
     376                { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
    365377        | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
    366378        | postfix_expression ARROW no_attr_identifier
    367                 { $$ = new CompositeExprNode2( build_pfieldSel( $1, new VarRefNode( $3 ) ) ); }
     379                { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
    368380        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
    369381        | postfix_expression ICR
    370                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::IncrPost, $1 ) ); }
     382                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
    371383        | postfix_expression DECR
    372                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::DecrPost, $1 ) ); }
     384                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
    373385        | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
    374                 { $$ = new CompoundLiteralNode( $2, new InitializerNode( $5, true ) ); }
     386                { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
    375387        | postfix_expression '{' argument_expression_list '}' // CFA
    376388                {
    377                         Token fn; fn.str = new std::string( "?{}" ); // location undefined
    378                         $$ = new CompositeExprNode( new VarRefNode( fn ), (ExpressionNode *)( $1 )->set_link( $3 ) );
     389                        Token fn;
     390                        fn.str = new std::string( "?{}" ); // location undefined
     391                        $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_link( $3 ) ) );
    379392                }
    380393        ;
    … …  
    390403                { $$ = 0; }                                                                             // use default argument
    391404        | assignment_expression
    392         | no_attr_identifier ':' assignment_expression
    393                 { $$ = $3->set_argName( $1 ); }
    394                 // Only a list of no_attr_identifier_or_type_name is allowed in this context. However, there is insufficient
    395                 // look ahead to distinguish between this list of parameter names and a tuple, so the tuple form must be used
    396                 // with an appropriate semantic check.
    397         | '[' push assignment_expression pop ']' ':' assignment_expression
    398                 { $$ = $7->set_argName( $3 ); }
    399         | '[' push assignment_expression ',' tuple_expression_list pop ']' ':' assignment_expression
    400                 { $$ = $9->set_argName( new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 )))); }
    401405        ;
    402406
    … …  
    408412field:                                                                                                  // CFA, tuple field selector
    409413        no_attr_identifier
    410                 { $$ = new VarRefNode( $1 ); }
     414                { $$ = new ExpressionNode( build_varref( $1 ) ); }
    411415        // ambiguity with .0 so space required after field-selection, e.g.
    412416                //   struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1;
    413417        | no_attr_identifier '.' field
    414                 { $$ = new CompositeExprNode2( build_fieldSel( $3, new VarRefNode( $1 ) ) ); }
     418                { $$ = new ExpressionNode( build_fieldSel( $3, build_varref( $1 ) ) ); }
    415419        | no_attr_identifier '.' '[' push field_list pop ']'
    416                 { $$ = new CompositeExprNode2( build_fieldSel( $5, new VarRefNode( $1 ) ) ); }
     420                { $$ = new ExpressionNode( build_fieldSel( $5, build_varref( $1 ) ) ); }
    417421        | no_attr_identifier ARROW field
    418                 { $$ = new CompositeExprNode2( build_pfieldSel( $3, new VarRefNode( $1 ) ) ); }
     422                { $$ = new ExpressionNode( build_pfieldSel( $3, build_varref( $1 ) ) ); }
    419423        | no_attr_identifier ARROW '[' push field_list pop ']'
    420                 { $$ = new CompositeExprNode2( build_pfieldSel( $5, new VarRefNode( $1 ) ) ); }
     424                { $$ = new ExpressionNode( build_pfieldSel( $5, build_varref( $1 ) ) ); }
    421425        ;
    422426
    … …  
    428432                { $$ = $1; }
    429433        | string_literal_list
    430                 { $$ = $1; }
     434                { $$ = new ExpressionNode( $1 ); }
    431435        | EXTENSION cast_expression                                                     // GCC
    432436                { $$ = $2->set_extension( true ); }
    … …  
    435439                //              { * int X; } // CFA declaration of pointer to int
    436440        | ptrref_operator cast_expression                                       // CFA
    437                 { $$ = $1 == OperatorNode::AddressOf ? (ExpressionNode*) new CompositeExprNode2( build_addressOf( $2 ) )
    438                                                                                         : (ExpressionNode*)new CompositeExprNode( new OperatorNode ( $1 ), $2 ); }
     441                {
     442                        switch ( $1 ) {
     443                          case OperKinds::AddressOf:
     444                                $$ = new ExpressionNode( build_addressOf( $2 ) );
     445                                break;
     446                          case OperKinds::PointTo:
     447                                $$ = new ExpressionNode( build_unary_val( $1, $2 ) );
     448                                break;
     449                          default:
     450                                assert( false );
     451                        }
     452                }
    439453        | unary_operator cast_expression
    440                 { $$ = new CompositeExprNode( $1, $2 ); }
     454                { $$ = new ExpressionNode( build_unary_val( $1, $2 ) ); }
    441455        | ICR unary_expression
    442                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::Incr, $2 ) ); }
     456                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Incr, $2 ) ); }
    443457        | DECR unary_expression
    444                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::Decr, $2 ) ); }
     458                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
    445459        | SIZEOF unary_expression
    446                 { $$ = new CompositeExprNode2( build_sizeOf( $2 ) ); }
     460                { $$ = new ExpressionNode( build_sizeOfexpr( $2 ) ); }
    447461        | SIZEOF '(' type_name_no_function ')'
    448                 { $$ = new CompositeExprNode2( build_sizeOf( new TypeValueNode( $3 ) ) ); }
     462                { $$ = new ExpressionNode( build_sizeOftype( $3 ) ); }
     463        | ALIGNOF unary_expression                                                      // GCC, variable alignment
     464                { $$ = new ExpressionNode( build_alignOfexpr( $2 ) ); }
     465        | ALIGNOF '(' type_name_no_function ')'                         // GCC, type alignment
     466                { $$ = new ExpressionNode( build_alignOftype( $3 ) ); }
    449467        | OFFSETOF '(' type_name_no_function ',' no_attr_identifier ')'
    450                 { $$ = new CompositeExprNode2( build_offsetOf( new TypeValueNode( $3 ), new VarRefNode( $5 ) ) ); }
     468                { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
    451469        | ATTR_IDENTIFIER
    452                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ) ); }
     470                { $$ = new ExpressionNode( build_attrexpr( build_varref( $1 ), nullptr ) ); }
     471        | ATTR_IDENTIFIER '(' argument_expression ')'
     472                { $$ = new ExpressionNode( build_attrexpr( build_varref( $1 ), $3 ) ); }
    453473        | ATTR_IDENTIFIER '(' type_name ')'
    454                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), new TypeValueNode( $3 ) ); }
    455         | ATTR_IDENTIFIER '(' argument_expression ')'
    456                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), $3 ); }
    457         | ALIGNOF unary_expression                                                      // GCC, variable alignment
    458                 { $$ = new CompositeExprNode2( build_alignOf( $2 ) ); }
    459         | ALIGNOF '(' type_name_no_function ')'                         // GCC, type alignment
    460                 { $$ = new CompositeExprNode2( build_alignOf( new TypeValueNode( $3 ) ) ); }
     474                { $$ = new ExpressionNode( build_attrtype( build_varref( $1 ), $3 ) ); }
    461475//      | ANDAND IDENTIFIER                                                                     // GCC, address of label
    462 //              { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( $2, true ) ); }
     476//              { $$ = new ExpressionNode( new OperatorNode( OperKinds::LabelAddress ), new ExpressionNode( build_varref( $2, true ) ); }
    463477        ;
    464478
    465479ptrref_operator:
    466         '*'                                                                                     { $$ = OperatorNode::PointTo; }
    467         | '&'                                                                           { $$ = OperatorNode::AddressOf; }
     480        '*'                                                                                     { $$ = OperKinds::PointTo; }
     481        | '&'                                                                           { $$ = OperKinds::AddressOf; }
    468482                // GCC, address of label must be handled by semantic check for ref,ref,label
    469         | ANDAND                                                                        { $$ = OperatorNode::And; }
     483//      | ANDAND                                                                        { $$ = OperKinds::And; }
    470484        ;
    471485
    472486unary_operator:
    473         '+'                                                                                     { $$ = new OperatorNode( OperatorNode::UnPlus ); }
    474         | '-'                                                                           { $$ = new OperatorNode( OperatorNode::UnMinus ); }
    475         | '!'                                                                           { $$ = new OperatorNode( OperatorNode::Neg ); }
    476         | '~'                                                                           { $$ = new OperatorNode( OperatorNode::BitNeg ); }
     487        '+'                                                                                     { $$ = OperKinds::UnPlus; }
     488        | '-'                                                                           { $$ = OperKinds::UnMinus; }
     489        | '!'                                                                           { $$ = OperKinds::Neg; }
     490        | '~'                                                                           { $$ = OperKinds::BitNeg; }
    477491        ;
    478492
    … …  
    480494        unary_expression
    481495        | '(' type_name_no_function ')' cast_expression
    482                 { $$ = new CompositeExprNode2( build_cast( new TypeValueNode( $2 ), $4 ) ); }
     496                { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
    483497        | '(' type_name_no_function ')' tuple
    484                 { $$ = new CompositeExprNode2( build_cast( new TypeValueNode( $2 ), $4 ) ); }
     498                { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
    485499        ;
    486500
    … …  
    488502        cast_expression
    489503        | multiplicative_expression '*' cast_expression
    490                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Mul, $1, $3 ) ); }
     504                { $$ = new ExpressionNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
    491505        | multiplicative_expression '/' cast_expression
    492                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Div, $1, $3 ) ); }
     506                { $$ = new ExpressionNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
    493507        | multiplicative_expression '%' cast_expression
    494                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Mod, $1, $3 ) ); }
     508                { $$ = new ExpressionNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
    495509        ;
    496510
    … …  
    498512        multiplicative_expression
    499513        | additive_expression '+' multiplicative_expression
    500                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Plus, $1, $3 ) ); }
     514                { $$ = new ExpressionNode( build_binary_val( OperKinds::Plus, $1, $3 ) ); }
    501515        | additive_expression '-' multiplicative_expression
    502                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Minus, $1, $3 ) ); }
     516                { $$ = new ExpressionNode( build_binary_val( OperKinds::Minus, $1, $3 ) ); }
    503517        ;
    504518
    … …  
    506520        additive_expression
    507521        | shift_expression LS additive_expression
    508                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LShift, $1, $3 ) ); }
     522                { $$ = new ExpressionNode( build_binary_val( OperKinds::LShift, $1, $3 ) ); }
    509523        | shift_expression RS additive_expression
    510                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::RShift, $1, $3 ) ); }
     524                { $$ = new ExpressionNode( build_binary_val( OperKinds::RShift, $1, $3 ) ); }
    511525        ;
    512526
    … …  
    514528        shift_expression
    515529        | relational_expression '<' shift_expression
    516                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LThan, $1, $3 ) ); }
     530                { $$ = new ExpressionNode( build_binary_val( OperKinds::LThan, $1, $3 ) ); }
    517531        | relational_expression '>' shift_expression
    518                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::GThan, $1, $3 ) ); }
     532                { $$ = new ExpressionNode( build_binary_val( OperKinds::GThan, $1, $3 ) ); }
    519533        | relational_expression LE shift_expression
    520                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LEThan, $1, $3 ) ); }
     534                { $$ = new ExpressionNode( build_binary_val( OperKinds::LEThan, $1, $3 ) ); }
    521535        | relational_expression GE shift_expression
    522                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::GEThan, $1, $3 ) ); }
     536                { $$ = new ExpressionNode( build_binary_val( OperKinds::GEThan, $1, $3 ) ); }
    523537        ;
    524538
    … …  
    526540        relational_expression
    527541        | equality_expression EQ relational_expression
    528                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Eq, $1, $3 ) ); }
     542                { $$ = new ExpressionNode( build_binary_val( OperKinds::Eq, $1, $3 ) ); }
    529543        | equality_expression NE relational_expression
    530                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Neq, $1, $3 ) ); }
     544                { $$ = new ExpressionNode( build_binary_val( OperKinds::Neq, $1, $3 ) ); }
    531545        ;
    532546
    … …  
    534548        equality_expression
    535549        | AND_expression '&' equality_expression
    536                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::BitAnd, $1, $3 ) ); }
     550                { $$ = new ExpressionNode( build_binary_val( OperKinds::BitAnd, $1, $3 ) ); }
    537551        ;
    538552
    … …  
    540554        AND_expression
    541555        | exclusive_OR_expression '^' AND_expression
    542                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Xor, $1, $3 ) ); }
     556                { $$ = new ExpressionNode( build_binary_val( OperKinds::Xor, $1, $3 ) ); }
    543557        ;
    544558
    … …  
    546560        exclusive_OR_expression
    547561        | inclusive_OR_expression '|' exclusive_OR_expression
    548                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::BitOr, $1, $3 ) ); }
     562                { $$ = new ExpressionNode( build_binary_val( OperKinds::BitOr, $1, $3 ) ); }
    549563        ;
    550564
    … …  
    552566        inclusive_OR_expression
    553567        | logical_AND_expression ANDAND inclusive_OR_expression
    554                 { $$ = new CompositeExprNode2( build_and_or( $1, $3, true ) ); }
     568                { $$ = new ExpressionNode( build_and_or( $1, $3, true ) ); }
    555569        ;
    556570
    … …  
    558572        logical_AND_expression
    559573        | logical_OR_expression OROR logical_AND_expression
    560                 { $$ = new CompositeExprNode2( build_and_or( $1, $3, false ) ); }
     574                { $$ = new ExpressionNode( build_and_or( $1, $3, false ) ); }
    561575        ;
    562576
    … …  
    564578        logical_OR_expression
    565579        | logical_OR_expression '?' comma_expression ':' conditional_expression
    566                 { $$ = new CompositeExprNode2( build_cond( $1, $3, $5 ) ); }
     580                { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
     581                // FIX ME: this hack computes $1 twice
    567582        | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
    568                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), $1, $4 ); }
     583                { $$ = new ExpressionNode( build_cond( $1, $1, $4 ) ); }
    569584        | logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression
    570                 { $$ = new CompositeExprNode2( build_cond( $1, $3, $5 ) ); }
     585                { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
    571586        ;
    572587
    … …  
    578593                // CFA, assignment is separated from assignment_operator to ensure no assignment operations for tuples
    579594        conditional_expression
    580         | unary_expression '=' assignment_expression
    581                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $3 ); }
    582595        | unary_expression assignment_operator assignment_expression
    583                 { $$ = new CompositeExprNode( $2, $1, $3 ); }
     596                { $$ = new ExpressionNode( build_binary_ptr( $2, $1, $3 ) ); }
    584597        | tuple assignment_opt                                                          // CFA, tuple expression
    585                 { $$ = ( $2 == 0 ) ? $1 : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $2 ); }
     598                { $$ = ( $2 == 0 ) ? $1 : new ExpressionNode( build_binary_ptr( OperKinds::Assign, $1, $2 ) ); }
    586599        ;
    587600
    588601assignment_expression_opt:
    589602        // empty
    590                 { $$ = new NullExprNode; }
     603                { $$ = nullptr; }
    591604        | assignment_expression
     605        ;
     606
     607assignment_operator:
     608        '='                                                                                     { $$ = OperKinds::Assign; }
     609        | MULTassign                                                            { $$ = OperKinds::MulAssn; }
     610        | DIVassign                                                                     { $$ = OperKinds::DivAssn; }
     611        | MODassign                                                                     { $$ = OperKinds::ModAssn; }
     612        | PLUSassign                                                            { $$ = OperKinds::PlusAssn; }
     613        | MINUSassign                                                           { $$ = OperKinds::MinusAssn; }
     614        | LSassign                                                                      { $$ = OperKinds::LSAssn; }
     615        | RSassign                                                                      { $$ = OperKinds::RSAssn; }
     616        | ANDassign                                                                     { $$ = OperKinds::AndAssn; }
     617        | ERassign                                                                      { $$ = OperKinds::ERAssn; }
     618        | ORassign                                                                      { $$ = OperKinds::OrAssn; }
    592619        ;
    593620
    … …  
    596623                // comma_expression in new_identifier_parameter_array and new_abstract_array
    597624        '[' ']'
    598                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
     625                { $$ = new ExpressionNode( build_tuple() ); }
    599626        | '[' push assignment_expression pop ']'
    600                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), $3 ); }
     627                { $$ = new ExpressionNode( build_tuple( $3 ) ); }
    601628        | '[' push ',' tuple_expression_list pop ']'
    602                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( $4 ) ); }
     629                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_link( $4 ) ) ); }
    603630        | '[' push assignment_expression ',' tuple_expression_list pop ']'
    604                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 ) ) ); }
     631                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_link( $5 ) ) ); }
    605632        ;
    606633
    … …  
    611638        ;
    612639
    613 assignment_operator:
    614         MULTassign                                                                      { $$ = new OperatorNode( OperatorNode::MulAssn ); }
    615         | DIVassign                                                                     { $$ = new OperatorNode( OperatorNode::DivAssn ); }
    616         | MODassign                                                                     { $$ = new OperatorNode( OperatorNode::ModAssn ); }
    617         | PLUSassign                                                            { $$ = new OperatorNode( OperatorNode::PlusAssn ); }
    618         | MINUSassign                                                           { $$ = new OperatorNode( OperatorNode::MinusAssn ); }
    619         | LSassign                                                                      { $$ = new OperatorNode( OperatorNode::LSAssn ); }
    620         | RSassign                                                                      { $$ = new OperatorNode( OperatorNode::RSAssn ); }
    621         | ANDassign                                                                     { $$ = new OperatorNode( OperatorNode::AndAssn ); }
    622         | ERassign                                                                      { $$ = new OperatorNode( OperatorNode::ERAssn ); }
    623         | ORassign                                                                      { $$ = new OperatorNode( OperatorNode::OrAssn ); }
    624         ;
    625 
    626640comma_expression:
    627641        assignment_expression
    628         | comma_expression ',' assignment_expression    // { $$ = (ExpressionNode *)$1->add_to_list( $3 ); }
    629         //{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Comma ), $1, $3 ); }
    630                 { $$ = new CompositeExprNode2( build_comma( $1, $3 ) ); }
     642        | comma_expression ',' assignment_expression
     643                { $$ = new ExpressionNode( build_comma( $1, $3 ) ); }
    631644        ;
    632645
    … …  
    650663        | '^' postfix_expression '{' argument_expression_list '}' ';' // CFA
    651664                {
    652                         Token fn; fn.str = new std::string( "^?{}" ); // location undefined
    653                         $$ = new StatementNode( StatementNode::Exp, new CompositeExprNode( new VarRefNode( fn ),
    654                                 (ExpressionNode *)( $2 )->set_link( $4 ) ), 0 );
     665                        Token fn;
     666                        fn.str = new std::string( "^?{}" ); // location undefined
     667                        $$ = new StatementNode( StatementNode::Exp, new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_link( $4 ) ) ), 0 );
    655668                }
    656669        ;
    … …  
    710723        IF '(' comma_expression ')' statement                           %prec THEN
    711724                // explicitly deal with the shift/reduce conflict on if/else
    712                 { $$ = new StatementNode( StatementNode::If, $3, $5 ); }
     725                //{ $$ = new StatementNode( StatementNode::If, $3, $5 ); }
     726                { $$ = new StatementNode2( build_if( $3, $5, nullptr ) ); }
    713727        | IF '(' comma_expression ')' statement ELSE statement
    714                 { $$ = new StatementNode( StatementNode::If, $3, (StatementNode *)mkList((*$5, *$7 )) ); }
     728                //{ $$ = new StatementNode( StatementNode::If, $3, (StatementNode *)mkList((*$5, *$7 )) ); }
     729                { $$ = new StatementNode2( build_if( $3, $5, $7 ) ); }
    715730        | SWITCH '(' comma_expression ')' case_clause           // CFA
    716                 { $$ = new StatementNode( StatementNode::Switch, $3, $5 ); }
     731                //{ $$ = new StatementNode( StatementNode::Switch, $3, $5 ); }
     732                { $$ = new StatementNode2( build_switch( $3, $5 ) ); }
    717733        | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA
    718734                {
    719                         StatementNode *sw = new StatementNode( StatementNode::Switch, $3, $8 );
     735                        StatementNode *sw = new StatementNode2( build_switch( $3, $8 ) );
    720736                        // The semantics of the declaration list is changed to include associated initialization, which is performed
    721737                        // *before* the transfer to the appropriate case clause by hoisting the declarations into a compound
    … …  
    726742                }
    727743        | CHOOSE '(' comma_expression ')' case_clause           // CFA
    728                 { $$ = new StatementNode( StatementNode::Switch, $3, $5 ); }
     744                //{ $$ = new StatementNode( StatementNode::Switch, $3, $5 ); }
     745                { $$ = new StatementNode2( build_switch( $3, $5 ) ); }
    729746        | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt choose_clause_list_opt '}' // CFA
    730747                {
    731                         StatementNode *sw = new StatementNode( StatementNode::Switch, $3, $8 );
     748                        //StatementNode *sw = new StatementNode( StatementNode::Switch, $3, $8 );
     749                        StatementNode *sw = new StatementNode2( build_switch( $3, $8 ) );
    732750                        $$ = $7 != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode( $7 ))->set_link( sw )) ) : sw;
    733751                }
    … …  
    740758        constant_expression                                                     { $$ = $1; }
    741759        | constant_expression ELLIPSIS constant_expression      // GCC, subrange
    742                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Range, $1, $3 ) ); }
     760                { $$ = new ExpressionNode( build_range( $1, $3 ) ); }
    743761        | subrange                                                                                      // CFA, subrange
    744762        ;
    … …  
    810828iteration_statement:
    811829        WHILE '(' comma_expression ')' statement
    812                 { $$ = new StatementNode( StatementNode::While, $3, $5 ); }
     830                { $$ = new StatementNode2( build_while( $3, $5 ) ); }
    813831        | DO statement WHILE '(' comma_expression ')' ';'
    814                 { $$ = new StatementNode( StatementNode::Do, $5, $2 ); }
     832                { $$ = new StatementNode2( build_while( $5, $2 ) ); }
    815833        | FOR '(' push for_control_expression ')' statement
    816                 { $$ = new StatementNode( StatementNode::For, $4, $6 ); }
     834                { $$ = new StatementNode2( build_for( $4, $6 ) ); }
    817835        ;
    818836
    819837for_control_expression:
    820838        comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt
    821                 { $$ = new ForCtlExprNode( $1, $4, $6 ); }
     839                { $$ = new ForCtl( $1, $4, $6 ); }
    822840        | declaration comma_expression_opt ';' comma_expression_opt // C99
    823                 { $$ = new ForCtlExprNode( $1, $2, $4 ); }
    824         ;
     841                { $$ = new ForCtl( $1, $2, $4 ); }
     842        ;
    825843
    826844jump_statement:
    … …  
    936954                { $$ = new AsmStmtNode( StatementNode::Asm, $2, $4, $6, $8, $10 ); }
    937955        | ASM asm_volatile_opt GOTO '(' string_literal_list ':' ':' asm_operands_opt ':' asm_clobbers_list_opt ':' label_list ')' ';'
    938         { $$ = new AsmStmtNode( StatementNode::Asm, $2, $5, 0, $8, $10, $12 ); }
     956                { $$ = new AsmStmtNode( StatementNode::Asm, $2, $5, 0, $8, $10, $12 ); }
    939957        ;
    940958
    … …  
    960978asm_operand:                                                                                    // GCC
    961979        string_literal_list '(' constant_expression ')'
    962                 { $$ = new AsmExprNode( 0, $1, $3 ); }
     980                { $$ = new ExpressionNode( build_asm( 0, $1, $3 ) ); }
    963981        | '[' constant_expression ']' string_literal_list '(' constant_expression ')'
    964                 { $$ = new AsmExprNode( $2, $4, $6 ); }
     982        { $$ = new ExpressionNode( build_asm( $2, $4, $6 ) ); }
    965983        ;
    966984
    … …  
    969987                { $$ = 0; }                                                                             // use default argument
    970988        | string_literal_list
    971                 { $$ = $1; }
     989                { $$ = new ExpressionNode( $1 ); }
    972990        | asm_clobbers_list_opt ',' string_literal_list
    973                 { $$ = (ConstantNode *)$1->set_link( $3 ); }
     991        { $$ = (ExpressionNode *)$1->set_link( new ExpressionNode( $3 ) ); }
    974992        ;
    975993
    … …  
    17581776        designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
    17591777        | no_attr_identifier_or_type_name ':'                           // GCC, field name
    1760                 { $$ = new VarRefNode( $1 ); }
     1778                { $$ = new ExpressionNode( build_varref( $1 ) ); }
    17611779        ;
    17621780
    … …  
    17641782        designator
    17651783        | designator_list designator
    1766                 { $$ = (ExpressionNode *)( $1->set_link( $2 )); }
    1767         //| designator_list designator                                          { $$ = new CompositeExprNode( $1, $2 ); }
     1784                { $$ = (ExpressionNode *)( $1->set_link( $2 ) ); }
     1785        //| designator_list designator                                          { $$ = new ExpressionNode( $1, $2 ); }
    17681786        ;
    17691787
    17701788designator:
    1771                 // lexer ambiguity: designator ".0" is floating-point constant or designator for name 0 only ".0" and ".1"
    1772                 // allowed => semantic check
    1773         FLOATINGconstant
    1774                 { $$ = new DesignatorNode( new VarRefNode( $1 ) ); }
    1775         | '.' no_attr_identifier_or_type_name                           // C99, field name
    1776                 { $$ = new DesignatorNode( new VarRefNode( $2 ) ); }
     1789        '.' no_attr_identifier_or_type_name                                     // C99, field name
     1790                { $$ = new ExpressionNode( build_varref( $2 ) ); }
    17771791        | '[' push assignment_expression pop ']'                        // C99, single array element
    17781792                // assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple.
    1779                 { $$ = new DesignatorNode( $3, true ); }
     1793                { $$ = $3; }
    17801794        | '[' push subrange pop ']'                                                     // CFA, multiple array elements
    1781                 { $$ = new DesignatorNode( $3, true ); }
     1795                { $$ = $3; }
    17821796        | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
    1783                 { $$ = new DesignatorNode( new CompositeExprNode2( build_opr2( OperatorNode::Range, $3, $5 ) ), true ); }
     1797                { $$ = new ExpressionNode( build_range( $3, $5 ) ); }
    17841798        | '.' '[' push field_list pop ']'                                       // CFA, tuple field selector
    1785                 { $$ = new DesignatorNode( $4 ); }
     1799                { $$ = $4; }
    17861800        ;
    17871801
    … …  
    18711885type_name_list:                                                                                 // CFA
    18721886        type_name
    1873                 { $$ = new TypeValueNode( $1 ); }
     1887                { $$ = new ExpressionNode( build_typevalue( $1 ) ); }
    18741888        | assignment_expression
    18751889        | type_name_list ',' type_name
    1876                 { $$ = (ExpressionNode *)( $1->set_link( new TypeValueNode( $3 ))); }
     1890                { $$ = (ExpressionNode *)( $1->set_link( new ExpressionNode( build_typevalue( $3 ) ) ) ); }
    18771891        | type_name_list ',' assignment_expression
    18781892                { $$ = (ExpressionNode *)( $1->set_link( $3 )); }
    … …  
    21102124subrange:
    21112125        constant_expression '~' constant_expression                     // CFA, integer subrange
    2112                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Range, $1, $3 ) ); }
     2126                { $$ = new ExpressionNode( build_range( $1, $3 ) ); }
    21132127        ;
    21142128
Note: See TracChangeset for help on using the changeset viewer.