Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/parser.yy

    r1b8f13f0 r098f7ff  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Nov  8 18:08:23 2018
    13 // Update Count     : 4052
     12// Last Modified On : Wed Aug  8 17:50:07 2018
     13// Update Count     : 3998
    1414//
    1515
    … …  
    187187
    188188ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
    189         ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->get_expr());
    190         if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
    191         type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
    192         } // if
    193189        return new ForCtrl(
    194                 distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
     190                distAttr( DeclarationNode::newTypeof( type ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
    195191                new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ),
    196                 new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
    197                                                                                           OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
    198 } // forCtrl
    199 
    200 ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
    201         if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->get_expr()) ) {
    202                 return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
    203         } else {
    204                 SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
    205         } // if
     192                new ExpressionNode( build_binary_val( OperKinds::PlusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
    206193} // forCtrl
    207194
    … …  
    227214
    228215// Types declaration for productions
    229 %union {
     216%union
     217{
    230218        Token tok;
    231219        ParseNode * pn;
    … …  
    266254%token ZERO_T ONE_T                                                                             // CFA
    267255%token VALIST                                                                                   // GCC
    268 %token TYPEOF BASETYPEOF LABEL                                                  // GCC
     256%token TYPEOF LABEL                                                                             // GCC
    269257%token ENUM STRUCT UNION
    270258%token EXCEPTION                                                                                // CFA
    … …  
    302290%token ANDassign        ERassign        ORassign                                // &=   ^=      |=
    303291
    304 %token ErangeUpEq       ErangeDown      ErangeDownEq                    // ~=   -~      -~=
     292%token Erange                                                                                   // ~=
    305293%token ATassign                                                                                 // @=
    306294
    … …  
    641629                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
    642630        | postfix_expression ARROW no_attr_identifier
    643                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
     631                {
     632                        $$ = new ExpressionNode( build_pfieldSel( $1, *$3 == "0" || *$3 == "1" ? build_constantInteger( *$3 ) : build_varref( $3 ) ) );
     633                }
    644634        | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
    645635                { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
    … …  
    11401130        | FOR '(' push for_control_expression ')' statement pop
    11411131                { $$ = new StatementNode( build_for( $4, $6 ) ); }
    1142         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
    1143                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), $4 ) ); }
    11441132        ;
    11451133
    11461134for_control_expression:
    1147         comma_expression                                                                        // CFA
    1148                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
    1149                                                 OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
     1135        comma_expression_opt                                                            // CFA
     1136                {
     1137                        if ( ! $1 ) {                                                           // => for ( ;; )
     1138                                $$ = new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr );
     1139                        } else {
     1140                                $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), OperKinds::LThan, $1->clone(),
     1141                                                         new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
     1142                        } // if
     1143                }
    11501144        | constant_expression inclexcl constant_expression      // CFA
    11511145                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    11521146        | constant_expression inclexcl constant_expression '~' constant_expression // CFA
    11531147                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
    1154         | comma_expression ';' comma_expression                         // CFA
    1155                 { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
    1156                                                 OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    1157         | comma_expression ';' constant_expression inclexcl constant_expression // CFA
    1158                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    1159         | comma_expression ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
    1160                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
    1161         | comma_expression ';' comma_expression_opt ';' comma_expression_opt
     1148        | comma_expression_opt ';' comma_expression                     // CFA
     1149                {
     1150                        if ( ! $1 ) {
     1151                                SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
     1152                        } else if ( ! $3 ) {
     1153                                SemanticError( yylloc, "Missing loop range." ); $$ = nullptr;
     1154                        } else {
     1155                                if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
     1156                                        $$ = forCtrl( $3, new string( identifier->name ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), OperKinds::LThan, $3->clone(),
     1157                                                                 new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
     1158                                } else {
     1159                                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
     1160                                } // if
     1161                        } // if
     1162                }
     1163        | comma_expression_opt ';' constant_expression inclexcl constant_expression // CFA
     1164                {
     1165                        if ( ! $1 ) {
     1166                                SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
     1167                        } else {
     1168                                if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
     1169                                        $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
     1170                                } else {
     1171                                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
     1172                                } // if
     1173                        } // if
     1174                }
     1175        | comma_expression_opt ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
     1176                {
     1177                        if ( ! $1 ) {
     1178                                SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
     1179                        } else {
     1180                                if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
     1181                                        $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, $7 );
     1182                                } else {
     1183                                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
     1184                                } // if
     1185                        } // if
     1186                }
     1187        | comma_expression_opt ';' comma_expression_opt ';' comma_expression_opt
    11621188                { $$ = new ForCtrl( $1, $3, $5 ); }
    1163         | ';' comma_expression_opt ';' comma_expression_opt
    1164                 { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
    11651189        | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
    11661190                { $$ = new ForCtrl( $1, $2, $4 ); }
    … …  
    11701194        '~'
    11711195                { $$ = OperKinds::LThan; }
    1172         | ErangeUpEq
     1196        | Erange
    11731197                { $$ = OperKinds::LEThan; }
    1174         | ErangeDown
    1175                 { $$ = OperKinds::GThan; }
    1176         | ErangeDownEq
    1177                 { $$ = OperKinds::GEThan; }
    11781198        ;
    11791199
    … …  
    12901310
    12911311handler_clause:
    1292         handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement pop
     1312        handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
    12931313                { $$ = new StatementNode( build_catch( $1, $4, $6, $8 ) ); }
    1294         | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement pop
     1314        | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
    12951315                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $5, $7, $9 ) ) ); }
    12961316        ;
    … …  
    18241844
    18251845indirect_type:
    1826         TYPEOF '(' type ')'                                                                     // GCC: typeof( x ) y;
     1846        TYPEOF '(' type ')'                                                                     // GCC: typeof(x) y;
    18271847                { $$ = $3; }
    1828         | TYPEOF '(' comma_expression ')'                                       // GCC: typeof( a+b ) y;
     1848        | TYPEOF '(' comma_expression ')'                                       // GCC: typeof(a+b) y;
    18291849                { $$ = DeclarationNode::newTypeof( $3 ); }
    1830         | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof( x ) y;
    1831                 { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
    1832         | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
    1833                 { $$ = DeclarationNode::newTypeof( $3, true ); }
    1834         | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type( x ) y;
     1850        | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type(x) y;
    18351851                { $$ = DeclarationNode::newAttr( $1, $3 ); }
    1836         | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type( a+b ) y;
     1852        | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type(a+b) y;
    18371853                { $$ = DeclarationNode::newAttr( $1, $3 ); }
    18381854        | ZERO_T                                                                                        // CFA
Note: See TracChangeset for help on using the changeset viewer.