Changes in src/Parser/parser.yy [1b8f13f0:0982a056]

File:

• src/Parser/parser.yy (modified) (6 diffs)

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov  8 18:08:23 2018
-// Update Count     : 4052
+// Last Modified On : Thu Aug 30 17:02:25 2018
+// Update Count     : 4029
 //
 
@@ -186 +186 @@
 } // fieldDecl
 
+ExpressionNode *forInc( const OperKinds op ) {
+        return new ExpressionNode( build_constantInteger( *new string( op == OperKinds::LThan || op == OperKinds::LEThan ? "1" : "-1" ) ) );
+} // forInc
+
 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
-        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->get_expr());
+        ConstantExpr *constant = dynamic_cast<ConstantExpr *>(type->get_expr());
         if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
         type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
         } // if
         return new ForCtrl(
-                distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
+                distAttr( DeclarationNode::newTypeof( type ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
                 new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ),
-                new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
-                                                                                          OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
-} // forCtrl
-
-ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
-        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->get_expr()) ) {
-                return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
-        } else {
-                SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
-        } // if
+                new ExpressionNode( build_binary_val( OperKinds::PlusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
 } // forCtrl
 
@@ -266 +261 @@
 %token ZERO_T ONE_T                                                                             // CFA
 %token VALIST                                                                                   // GCC
-%token TYPEOF BASETYPEOF LABEL                                                  // GCC
+%token TYPEOF LABEL                                                                             // GCC
 %token ENUM STRUCT UNION
 %token EXCEPTION                                                                                // CFA
@@ -641 +636 @@
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression ARROW no_attr_identifier
-                { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
+                {
+                        $$ = new ExpressionNode( build_pfieldSel( $1, *$3 == "0" || *$3 == "1" ? build_constantInteger( *$3 ) : build_varref( $3 ) ) );
+                }
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
@@ -1140 +1137 @@
         | FOR '(' push for_control_expression ')' statement pop
                 { $$ = new StatementNode( build_for( $4, $6 ) ); }
-        | FOR '(' ')' statement                                                         // CFA => for ( ;; )
-                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), $4 ) ); }
         ;
 
 for_control_expression:
-        comma_expression                                                                        // CFA
-                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
-                                                OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+        comma_expression_opt                                                            // CFA
+                {
+                        if ( ! $1 ) {                                                           // => for ( ;; )
+                                $$ = new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr );
+                        } else {
+                                $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
+                                                          OperKinds::LThan, $1->clone(), forInc( OperKinds::LThan ) );
+                        } // if
+                }
         | constant_expression inclexcl constant_expression      // CFA
-                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, forInc( $2 ) ); }
         | constant_expression inclexcl constant_expression '~' constant_expression // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
-        | comma_expression ';' comma_expression                         // CFA
-                { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
-                                                OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | comma_expression ';' constant_expression inclexcl constant_expression // CFA
-                { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | comma_expression ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
-                { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
-        | comma_expression ';' comma_expression_opt ';' comma_expression_opt
+        | comma_expression_opt ';' comma_expression                     // CFA
+                {
+                        if ( ! $1 ) {
+                                SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
+                        } else if ( ! $3 ) {
+                                SemanticError( yylloc, "Missing loop range." ); $$ = nullptr;
+                        } else {
+                                if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
+                                        $$ = forCtrl( $3, new string( identifier->name ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
+                                                                  OperKinds::LThan, $3->clone(), forInc( OperKinds::LThan ) );
+                                } else {
+                                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
+                                } // if
+                        } // if
+                }
+        | comma_expression_opt ';' constant_expression inclexcl constant_expression // CFA
+                {
+                        if ( ! $1 ) {
+                                SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
+                        } else {
+                                if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
+                                        $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, forInc( $4 ) );
+                                } else {
+                                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
+                                } // if
+                        } // if
+                }
+        | comma_expression_opt ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
+                {
+                        if ( ! $1 ) {
+                                SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
+                        } else {
+                                if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
+                                        $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, $7 );
+                                } else {
+                                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
+                                } // if
+                        } // if
+                }
+        | comma_expression_opt ';' comma_expression_opt ';' comma_expression_opt
                 { $$ = new ForCtrl( $1, $3, $5 ); }
-        | ';' comma_expression_opt ';' comma_expression_opt
-                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
         | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
                 { $$ = new ForCtrl( $1, $2, $4 ); }
@@ -1824 +1855 @@
 
 indirect_type:
-        TYPEOF '(' type ')'                                                                     // GCC: typeof( x ) y;
+        TYPEOF '(' type ')'                                                                     // GCC: typeof(x) y;
                 { $$ = $3; }
-        | TYPEOF '(' comma_expression ')'                                       // GCC: typeof( a+b ) y;
+        | TYPEOF '(' comma_expression ')'                                       // GCC: typeof(a+b) y;
                 { $$ = DeclarationNode::newTypeof( $3 ); }
-        | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof( x ) y;
-                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
-        | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
-                { $$ = DeclarationNode::newTypeof( $3, true ); }
-        | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type( x ) y;
+        | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type(x) y;
                 { $$ = DeclarationNode::newAttr( $1, $3 ); }
-        | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type( a+b ) y;
+        | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type(a+b) y;
                 { $$ = DeclarationNode::newAttr( $1, $3 ); }
         | ZERO_T                                                                                        // CFA