Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/parser.yy

    r2f22cc4 r51e076e  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 10 13:09:53 2016
    13 // Update Count     : 1844
     12// Last Modified On : Fri Aug  5 08:15:57 2016
     13// Update Count     : 1721
    1414//
    1515
    … …  
    6060std::stack< LinkageSpec::Type > linkageStack;
    6161TypedefTable typedefTable;
    62 
    63 void 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
    6762%}
    6863
    … …  
    121116        DeclarationNode::TypeClass tclass;
    122117        StatementNode *sn;
    123         ConstantExpr *constant;
    124         ForCtl *fctl;
     118        ConstantNode *constant;
    125119        LabelNode *label;
    126120        InitializerNode *in;
    127         OperKinds op;
     121        OperatorNode::Type op;
    128122        bool flag;
    129123}
    … …  
    134128
    135129// expressions
    136 %type<en> constant
     130%type<constant> constant
    137131%type<en> tuple                                                 tuple_expression_list
    138 %type<op> ptrref_operator                               unary_operator                          assignment_operator
     132%type<op> ptrref_operator
     133%type<en> unary_operator                                assignment_operator
    139134%type<en> primary_expression                    postfix_expression                      unary_expression
    140135%type<en> cast_expression                               multiplicative_expression       additive_expression                     shift_expression
    … …  
    143138%type<en> constant_expression                   assignment_expression           assignment_expression_opt
    144139%type<en> comma_expression                              comma_expression_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
     140%type<en> argument_expression_list              argument_expression                     for_control_expression          assignment_opt
    148141%type<en> subrange
    149142%type<en> asm_operands_opt asm_operands_list asm_operand
    150143%type<label> label_list
    151 %type<en> asm_clobbers_list_opt
     144%type<constant> asm_clobbers_list_opt
    152145%type<flag> asm_volatile_opt
    153146
    … …  
    312305constant:
    313306                // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
    314 INTEGERconstant                                                                 { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
    315         | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
    316         | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( *$1 ) ); }
     307INTEGERconstant                                                                 { $$ = makeConstantInteger( *$1 ); }
     308        | FLOATINGconstant                                                      { $$ = makeConstantFloat( *$1 ); }
     309        | CHARACTERconstant                                                     { $$ = makeConstantChar( *$1 ); }
    317310        ;
    318311
    … …  
    339332
    340333string_literal_list:                                                                    // juxtaposed strings are concatenated
    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                 }
     334        STRINGliteral                                                           { $$ = makeConstantStr( *$1 ); }
     335        | string_literal_list STRINGliteral                     { $$ = $1->appendstr( $2 ); }
    348336        ;
    349337
    … …  
    352340primary_expression:
    353341        IDENTIFIER                                                                                      // typedef name cannot be used as a variable name
    354                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
     342                { $$ = new VarRefNode( $1 ); }
    355343        | zero_one
    356                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
     344                { $$ = new VarRefNode( $1 ); }
    357345        | '(' comma_expression ')'
    358346                { $$ = $2; }
    359347        | '(' compound_statement ')'                                            // GCC, lambda expression
    360         { $$ = new ExpressionNode( build_valexpr( $2 ) ); }
     348                { $$ = new ValofExprNode( $2 ); }
    361349        ;
    362350
    … …  
    368356                // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
    369357                // equivalent to the old x[i,j].
    370                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $4 ) ); }
     358                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Index, $1, $4 ) ); }
    371359        | postfix_expression '(' argument_expression_list ')'
    372                 { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
     360                { $$ = new CompositeExprNode( $1, $3 ); }
    373361        // ambiguity with .0 so space required after field-selection, e.g.
    374362                //   struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1;
    375363        | postfix_expression '.' no_attr_identifier
    376                 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
     364                { $$ = new CompositeExprNode2( build_fieldSel( $1, new VarRefNode( $3 ) ) ); }
    377365        | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
    378366        | postfix_expression ARROW no_attr_identifier
    379                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
     367                { $$ = new CompositeExprNode2( build_pfieldSel( $1, new VarRefNode( $3 ) ) ); }
    380368        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
    381369        | postfix_expression ICR
    382                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
     370                { $$ = new CompositeExprNode2( build_opr1( OperatorNode::IncrPost, $1 ) ); }
    383371        | postfix_expression DECR
    384                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
     372                { $$ = new CompositeExprNode2( build_opr1( OperatorNode::DecrPost, $1 ) ); }
    385373        | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
    386                 { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
     374                { $$ = new CompoundLiteralNode( $2, new InitializerNode( $5, true ) ); }
    387375        | postfix_expression '{' argument_expression_list '}' // CFA
    388376                {
    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 ) ) );
     377                        Token fn; fn.str = new std::string( "?{}" ); // location undefined
     378                        $$ = new CompositeExprNode( new VarRefNode( fn ), (ExpressionNode *)( $1 )->set_link( $3 ) );
    392379                }
    393380        ;
    … …  
    403390                { $$ = 0; }                                                                             // use default argument
    404391        | 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 )))); }
    405401        ;
    406402
    … …  
    412408field:                                                                                                  // CFA, tuple field selector
    413409        no_attr_identifier
    414                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
     410                { $$ = new VarRefNode( $1 ); }
    415411        // ambiguity with .0 so space required after field-selection, e.g.
    416412                //   struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1;
    417413        | no_attr_identifier '.' field
    418                 { $$ = new ExpressionNode( build_fieldSel( $3, build_varref( $1 ) ) ); }
     414                { $$ = new CompositeExprNode2( build_fieldSel( $3, new VarRefNode( $1 ) ) ); }
    419415        | no_attr_identifier '.' '[' push field_list pop ']'
    420                 { $$ = new ExpressionNode( build_fieldSel( $5, build_varref( $1 ) ) ); }
     416                { $$ = new CompositeExprNode2( build_fieldSel( $5, new VarRefNode( $1 ) ) ); }
    421417        | no_attr_identifier ARROW field
    422                 { $$ = new ExpressionNode( build_pfieldSel( $3, build_varref( $1 ) ) ); }
     418                { $$ = new CompositeExprNode2( build_pfieldSel( $3, new VarRefNode( $1 ) ) ); }
    423419        | no_attr_identifier ARROW '[' push field_list pop ']'
    424                 { $$ = new ExpressionNode( build_pfieldSel( $5, build_varref( $1 ) ) ); }
     420                { $$ = new CompositeExprNode2( build_pfieldSel( $5, new VarRefNode( $1 ) ) ); }
    425421        ;
    426422
    … …  
    432428                { $$ = $1; }
    433429        | string_literal_list
    434                 { $$ = new ExpressionNode( $1 ); }
     430                { $$ = $1; }
    435431        | EXTENSION cast_expression                                                     // GCC
    436432                { $$ = $2->set_extension( true ); }
    … …  
    439435                //              { * int X; } // CFA declaration of pointer to int
    440436        | ptrref_operator cast_expression                                       // CFA
    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                 }
     437                { $$ = $1 == OperatorNode::AddressOf ? (ExpressionNode*) new CompositeExprNode2( build_addressOf( $2 ) )
     438                                                                                        : (ExpressionNode*)new CompositeExprNode( new OperatorNode ( $1 ), $2 ); }
    453439        | unary_operator cast_expression
    454                 { $$ = new ExpressionNode( build_unary_val( $1, $2 ) ); }
     440                { $$ = new CompositeExprNode( $1, $2 ); }
    455441        | ICR unary_expression
    456                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Incr, $2 ) ); }
     442                { $$ = new CompositeExprNode2( build_opr1( OperatorNode::Incr, $2 ) ); }
    457443        | DECR unary_expression
    458                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
     444                { $$ = new CompositeExprNode2( build_opr1( OperatorNode::Decr, $2 ) ); }
    459445        | SIZEOF unary_expression
    460                 { $$ = new ExpressionNode( build_sizeOfexpr( $2 ) ); }
     446                { $$ = new CompositeExprNode2( build_sizeOf( $2 ) ); }
    461447        | SIZEOF '(' type_name_no_function ')'
    462                 { $$ = new ExpressionNode( build_sizeOftype( $3 ) ); }
     448                { $$ = new CompositeExprNode2( build_sizeOf( new TypeValueNode( $3 ) ) ); }
     449        | OFFSETOF '(' type_name_no_function ',' no_attr_identifier ')'
     450                { $$ = new CompositeExprNode2( build_offsetOf( new TypeValueNode( $3 ), new VarRefNode( $5 ) ) ); }
     451        | ATTR_IDENTIFIER
     452                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ) ); }
     453        | 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 ); }
    463457        | ALIGNOF unary_expression                                                      // GCC, variable alignment
    464                 { $$ = new ExpressionNode( build_alignOfexpr( $2 ) ); }
     458                { $$ = new CompositeExprNode2( build_alignOf( $2 ) ); }
    465459        | ALIGNOF '(' type_name_no_function ')'                         // GCC, type alignment
    466                 { $$ = new ExpressionNode( build_alignOftype( $3 ) ); }
    467         | OFFSETOF '(' type_name_no_function ',' no_attr_identifier ')'
    468                 { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
    469         | ATTR_IDENTIFIER
    470                 { $$ = new ExpressionNode( build_attrexpr( build_varref( $1 ), nullptr ) ); }
    471         | ATTR_IDENTIFIER '(' argument_expression ')'
    472                 { $$ = new ExpressionNode( build_attrexpr( build_varref( $1 ), $3 ) ); }
    473         | ATTR_IDENTIFIER '(' type_name ')'
    474                 { $$ = new ExpressionNode( build_attrtype( build_varref( $1 ), $3 ) ); }
     460                { $$ = new CompositeExprNode2( build_alignOf( new TypeValueNode( $3 ) ) ); }
    475461//      | ANDAND IDENTIFIER                                                                     // GCC, address of label
    476 //              { $$ = new ExpressionNode( new OperatorNode( OperKinds::LabelAddress ), new ExpressionNode( build_varref( $2, true ) ); }
     462//              { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( $2, true ) ); }
    477463        ;
    478464
    479465ptrref_operator:
    480         '*'                                                                                     { $$ = OperKinds::PointTo; }
    481         | '&'                                                                           { $$ = OperKinds::AddressOf; }
     466        '*'                                                                                     { $$ = OperatorNode::PointTo; }
     467        | '&'                                                                           { $$ = OperatorNode::AddressOf; }
    482468                // GCC, address of label must be handled by semantic check for ref,ref,label
    483 //      | ANDAND                                                                        { $$ = OperKinds::And; }
     469        | ANDAND                                                                        { $$ = OperatorNode::And; }
    484470        ;
    485471
    486472unary_operator:
    487         '+'                                                                                     { $$ = OperKinds::UnPlus; }
    488         | '-'                                                                           { $$ = OperKinds::UnMinus; }
    489         | '!'                                                                           { $$ = OperKinds::Neg; }
    490         | '~'                                                                           { $$ = OperKinds::BitNeg; }
     473        '+'                                                                                     { $$ = new OperatorNode( OperatorNode::UnPlus ); }
     474        | '-'                                                                           { $$ = new OperatorNode( OperatorNode::UnMinus ); }
     475        | '!'                                                                           { $$ = new OperatorNode( OperatorNode::Neg ); }
     476        | '~'                                                                           { $$ = new OperatorNode( OperatorNode::BitNeg ); }
    491477        ;
    492478
    … …  
    494480        unary_expression
    495481        | '(' type_name_no_function ')' cast_expression
    496                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
     482                { $$ = new CompositeExprNode2( build_cast( new TypeValueNode( $2 ), $4 ) ); }
    497483        | '(' type_name_no_function ')' tuple
    498                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
     484                { $$ = new CompositeExprNode2( build_cast( new TypeValueNode( $2 ), $4 ) ); }
    499485        ;
    500486
    … …  
    502488        cast_expression
    503489        | multiplicative_expression '*' cast_expression
    504                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
     490                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Mul, $1, $3 ) ); }
    505491        | multiplicative_expression '/' cast_expression
    506                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
     492                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Div, $1, $3 ) ); }
    507493        | multiplicative_expression '%' cast_expression
    508                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
     494                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Mod, $1, $3 ) ); }
    509495        ;
    510496
    … …  
    512498        multiplicative_expression
    513499        | additive_expression '+' multiplicative_expression
    514                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Plus, $1, $3 ) ); }
     500                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Plus, $1, $3 ) ); }
    515501        | additive_expression '-' multiplicative_expression
    516                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Minus, $1, $3 ) ); }
     502                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Minus, $1, $3 ) ); }
    517503        ;
    518504
    … …  
    520506        additive_expression
    521507        | shift_expression LS additive_expression
    522                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LShift, $1, $3 ) ); }
     508                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LShift, $1, $3 ) ); }
    523509        | shift_expression RS additive_expression
    524                 { $$ = new ExpressionNode( build_binary_val( OperKinds::RShift, $1, $3 ) ); }
     510                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::RShift, $1, $3 ) ); }
    525511        ;
    526512
    … …  
    528514        shift_expression
    529515        | relational_expression '<' shift_expression
    530                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LThan, $1, $3 ) ); }
     516                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LThan, $1, $3 ) ); }
    531517        | relational_expression '>' shift_expression
    532                 { $$ = new ExpressionNode( build_binary_val( OperKinds::GThan, $1, $3 ) ); }
     518                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::GThan, $1, $3 ) ); }
    533519        | relational_expression LE shift_expression
    534                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LEThan, $1, $3 ) ); }
     520                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LEThan, $1, $3 ) ); }
    535521        | relational_expression GE shift_expression
    536                 { $$ = new ExpressionNode( build_binary_val( OperKinds::GEThan, $1, $3 ) ); }
     522                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::GEThan, $1, $3 ) ); }
    537523        ;
    538524
    … …  
    540526        relational_expression
    541527        | equality_expression EQ relational_expression
    542                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Eq, $1, $3 ) ); }
     528                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Eq, $1, $3 ) ); }
    543529        | equality_expression NE relational_expression
    544                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Neq, $1, $3 ) ); }
     530                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Neq, $1, $3 ) ); }
    545531        ;
    546532
    … …  
    548534        equality_expression
    549535        | AND_expression '&' equality_expression
    550                 { $$ = new ExpressionNode( build_binary_val( OperKinds::BitAnd, $1, $3 ) ); }
     536                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::BitAnd, $1, $3 ) ); }
    551537        ;
    552538
    … …  
    554540        AND_expression
    555541        | exclusive_OR_expression '^' AND_expression
    556                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Xor, $1, $3 ) ); }
     542                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Xor, $1, $3 ) ); }
    557543        ;
    558544
    … …  
    560546        exclusive_OR_expression
    561547        | inclusive_OR_expression '|' exclusive_OR_expression
    562                 { $$ = new ExpressionNode( build_binary_val( OperKinds::BitOr, $1, $3 ) ); }
     548                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::BitOr, $1, $3 ) ); }
    563549        ;
    564550
    … …  
    566552        inclusive_OR_expression
    567553        | logical_AND_expression ANDAND inclusive_OR_expression
    568                 { $$ = new ExpressionNode( build_and_or( $1, $3, true ) ); }
     554                { $$ = new CompositeExprNode2( build_and_or( $1, $3, true ) ); }
    569555        ;
    570556
    … …  
    572558        logical_AND_expression
    573559        | logical_OR_expression OROR logical_AND_expression
    574                 { $$ = new ExpressionNode( build_and_or( $1, $3, false ) ); }
     560                { $$ = new CompositeExprNode2( build_and_or( $1, $3, false ) ); }
    575561        ;
    576562
    … …  
    578564        logical_OR_expression
    579565        | logical_OR_expression '?' comma_expression ':' conditional_expression
    580                 { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
    581                 // FIX ME: this hack computes $1 twice
     566                { $$ = new CompositeExprNode2( build_cond( $1, $3, $5 ) ); }
    582567        | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
    583                 { $$ = new ExpressionNode( build_cond( $1, $1, $4 ) ); }
     568                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), $1, $4 ); }
    584569        | logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression
    585                 { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
     570                { $$ = new CompositeExprNode2( build_cond( $1, $3, $5 ) ); }
    586571        ;
    587572
    … …  
    593578                // CFA, assignment is separated from assignment_operator to ensure no assignment operations for tuples
    594579        conditional_expression
     580        | unary_expression '=' assignment_expression
     581                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $3 ); }
    595582        | unary_expression assignment_operator assignment_expression
    596                 { $$ = new ExpressionNode( build_binary_ptr( $2, $1, $3 ) ); }
     583                { $$ = new CompositeExprNode( $2, $1, $3 ); }
    597584        | tuple assignment_opt                                                          // CFA, tuple expression
    598                 { $$ = ( $2 == 0 ) ? $1 : new ExpressionNode( build_binary_ptr( OperKinds::Assign, $1, $2 ) ); }
     585                { $$ = ( $2 == 0 ) ? $1 : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $2 ); }
    599586        ;
    600587
    601588assignment_expression_opt:
    602589        // empty
    603                 { $$ = nullptr; }
     590                { $$ = new NullExprNode; }
    604591        | assignment_expression
    605         ;
    606 
    607 assignment_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; }
    619592        ;
    620593
    … …  
    623596                // comma_expression in new_identifier_parameter_array and new_abstract_array
    624597        '[' ']'
    625                 { $$ = new ExpressionNode( build_tuple() ); }
     598                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
    626599        | '[' push assignment_expression pop ']'
    627                 { $$ = new ExpressionNode( build_tuple( $3 ) ); }
     600                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), $3 ); }
    628601        | '[' push ',' tuple_expression_list pop ']'
    629                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_link( $4 ) ) ); }
     602                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( $4 ) ); }
    630603        | '[' push assignment_expression ',' tuple_expression_list pop ']'
    631                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_link( $5 ) ) ); }
     604                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 ) ) ); }
    632605        ;
    633606
    … …  
    638611        ;
    639612
     613assignment_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
    640626comma_expression:
    641627        assignment_expression
    642         | comma_expression ',' assignment_expression
    643                 { $$ = new ExpressionNode( build_comma( $1, $3 ) ); }
     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 ) ); }
    644631        ;
    645632
    … …  
    663650        | '^' postfix_expression '{' argument_expression_list '}' ';' // CFA
    664651                {
    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 );
     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 );
    668655                }
    669656        ;
    … …  
    723710        IF '(' comma_expression ')' statement                           %prec THEN
    724711                // explicitly deal with the shift/reduce conflict on if/else
    725                 //{ $$ = new StatementNode( StatementNode::If, $3, $5 ); }
    726                 { $$ = new StatementNode2( build_if( $3, $5, nullptr ) ); }
     712                { $$ = new StatementNode( StatementNode::If, $3, $5 ); }
    727713        | IF '(' comma_expression ')' statement ELSE statement
    728                 //{ $$ = new StatementNode( StatementNode::If, $3, (StatementNode *)mkList((*$5, *$7 )) ); }
    729                 { $$ = new StatementNode2( build_if( $3, $5, $7 ) ); }
     714                { $$ = new StatementNode( StatementNode::If, $3, (StatementNode *)mkList((*$5, *$7 )) ); }
    730715        | SWITCH '(' comma_expression ')' case_clause           // CFA
    731                 //{ $$ = new StatementNode( StatementNode::Switch, $3, $5 ); }
    732                 { $$ = new StatementNode2( build_switch( $3, $5 ) ); }
     716                { $$ = new StatementNode( StatementNode::Switch, $3, $5 ); }
    733717        | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA
    734718                {
    735                         StatementNode *sw = new StatementNode2( build_switch( $3, $8 ) );
     719                        StatementNode *sw = new StatementNode( StatementNode::Switch, $3, $8 );
    736720                        // The semantics of the declaration list is changed to include associated initialization, which is performed
    737721                        // *before* the transfer to the appropriate case clause by hoisting the declarations into a compound
    … …  
    742726                }
    743727        | CHOOSE '(' comma_expression ')' case_clause           // CFA
    744                 //{ $$ = new StatementNode( StatementNode::Switch, $3, $5 ); }
    745                 { $$ = new StatementNode2( build_switch( $3, $5 ) ); }
     728                { $$ = new StatementNode( StatementNode::Switch, $3, $5 ); }
    746729        | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt choose_clause_list_opt '}' // CFA
    747730                {
    748                         //StatementNode *sw = new StatementNode( StatementNode::Switch, $3, $8 );
    749                         StatementNode *sw = new StatementNode2( build_switch( $3, $8 ) );
     731                        StatementNode *sw = new StatementNode( StatementNode::Switch, $3, $8 );
    750732                        $$ = $7 != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode( $7 ))->set_link( sw )) ) : sw;
    751733                }
    … …  
    758740        constant_expression                                                     { $$ = $1; }
    759741        | constant_expression ELLIPSIS constant_expression      // GCC, subrange
    760                 { $$ = new ExpressionNode( build_range( $1, $3 ) ); }
     742                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Range, $1, $3 ) ); }
    761743        | subrange                                                                                      // CFA, subrange
    762744        ;
    … …  
    828810iteration_statement:
    829811        WHILE '(' comma_expression ')' statement
    830                 { $$ = new StatementNode2( build_while( $3, $5 ) ); }
     812                { $$ = new StatementNode( StatementNode::While, $3, $5 ); }
    831813        | DO statement WHILE '(' comma_expression ')' ';'
    832                 { $$ = new StatementNode2( build_while( $5, $2 ) ); }
     814                { $$ = new StatementNode( StatementNode::Do, $5, $2 ); }
    833815        | FOR '(' push for_control_expression ')' statement
    834                 { $$ = new StatementNode2( build_for( $4, $6 ) ); }
     816                { $$ = new StatementNode( StatementNode::For, $4, $6 ); }
    835817        ;
    836818
    837819for_control_expression:
    838820        comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt
    839                 { $$ = new ForCtl( $1, $4, $6 ); }
     821                { $$ = new ForCtlExprNode( $1, $4, $6 ); }
    840822        | declaration comma_expression_opt ';' comma_expression_opt // C99
    841                 { $$ = new ForCtl( $1, $2, $4 ); }
    842         ;
     823                { $$ = new ForCtlExprNode( $1, $2, $4 ); }
     824        ;
    843825
    844826jump_statement:
    … …  
    954936                { $$ = new AsmStmtNode( StatementNode::Asm, $2, $4, $6, $8, $10 ); }
    955937        | ASM asm_volatile_opt GOTO '(' string_literal_list ':' ':' asm_operands_opt ':' asm_clobbers_list_opt ':' label_list ')' ';'
    956                 { $$ = new AsmStmtNode( StatementNode::Asm, $2, $5, 0, $8, $10, $12 ); }
     938        { $$ = new AsmStmtNode( StatementNode::Asm, $2, $5, 0, $8, $10, $12 ); }
    957939        ;
    958940
    … …  
    978960asm_operand:                                                                                    // GCC
    979961        string_literal_list '(' constant_expression ')'
    980                 { $$ = new ExpressionNode( build_asm( 0, $1, $3 ) ); }
     962                { $$ = new AsmExprNode( 0, $1, $3 ); }
    981963        | '[' constant_expression ']' string_literal_list '(' constant_expression ')'
    982         { $$ = new ExpressionNode( build_asm( $2, $4, $6 ) ); }
     964                { $$ = new AsmExprNode( $2, $4, $6 ); }
    983965        ;
    984966
    … …  
    987969                { $$ = 0; }                                                                             // use default argument
    988970        | string_literal_list
    989                 { $$ = new ExpressionNode( $1 ); }
     971                { $$ = $1; }
    990972        | asm_clobbers_list_opt ',' string_literal_list
    991         { $$ = (ExpressionNode *)$1->set_link( new ExpressionNode( $3 ) ); }
     973                { $$ = (ConstantNode *)$1->set_link( $3 ); }
    992974        ;
    993975
    … …  
    17761758        designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
    17771759        | no_attr_identifier_or_type_name ':'                           // GCC, field name
    1778                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
     1760                { $$ = new VarRefNode( $1 ); }
    17791761        ;
    17801762
    … …  
    17821764        designator
    17831765        | designator_list designator
    1784                 { $$ = (ExpressionNode *)( $1->set_link( $2 ) ); }
    1785         //| designator_list designator                                          { $$ = new ExpressionNode( $1, $2 ); }
     1766                { $$ = (ExpressionNode *)( $1->set_link( $2 )); }
     1767        //| designator_list designator                                          { $$ = new CompositeExprNode( $1, $2 ); }
    17861768        ;
    17871769
    17881770designator:
    1789         '.' no_attr_identifier_or_type_name                                     // C99, field name
    1790                 { $$ = new ExpressionNode( build_varref( $2 ) ); }
     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 ) ); }
    17911777        | '[' push assignment_expression pop ']'                        // C99, single array element
    17921778                // assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple.
    1793                 { $$ = $3; }
     1779                { $$ = new DesignatorNode( $3, true ); }
    17941780        | '[' push subrange pop ']'                                                     // CFA, multiple array elements
    1795                 { $$ = $3; }
     1781                { $$ = new DesignatorNode( $3, true ); }
    17961782        | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
    1797                 { $$ = new ExpressionNode( build_range( $3, $5 ) ); }
     1783                { $$ = new DesignatorNode( new CompositeExprNode2( build_opr2( OperatorNode::Range, $3, $5 ) ), true ); }
    17981784        | '.' '[' push field_list pop ']'                                       // CFA, tuple field selector
    1799                 { $$ = $4; }
     1785                { $$ = new DesignatorNode( $4 ); }
    18001786        ;
    18011787
    … …  
    18851871type_name_list:                                                                                 // CFA
    18861872        type_name
    1887                 { $$ = new ExpressionNode( build_typevalue( $1 ) ); }
     1873                { $$ = new TypeValueNode( $1 ); }
    18881874        | assignment_expression
    18891875        | type_name_list ',' type_name
    1890                 { $$ = (ExpressionNode *)( $1->set_link( new ExpressionNode( build_typevalue( $3 ) ) ) ); }
     1876                { $$ = (ExpressionNode *)( $1->set_link( new TypeValueNode( $3 ))); }
    18911877        | type_name_list ',' assignment_expression
    18921878                { $$ = (ExpressionNode *)( $1->set_link( $3 )); }
    … …  
    21242110subrange:
    21252111        constant_expression '~' constant_expression                     // CFA, integer subrange
    2126                 { $$ = new ExpressionNode( build_range( $1, $3 ) ); }
     2112                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Range, $1, $3 ) ); }
    21272113        ;
    21282114
Note: See TracChangeset for help on using the changeset viewer.