Changes in src/Parser/parser.yy [01afd8d:253d0b4]

File:

• src/Parser/parser.yy (modified) (13 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 Jun 27 14:45:57 2024
-// Update Count     : 6705
+// Last Modified On : Mon Jun 24 22:45:20 2024
+// Update Count     : 6684
 //
 
@@ -224 +224 @@
 #define UPDOWN( compop, left, right ) (compop == OperKinds::LThan || compop == OperKinds::LEThan ? left : right)
 #define MISSING_ANON_FIELD "illegal syntax, missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body."
-#define MISSING_LOW "illegal syntax, missing low value for ascanding range so index is uninitialized."
-#define MISSING_HIGH "illegal syntax, missing high value for descending range so index is uninitialized."
-
-static ForCtrl * makeForCtrl( const CodeLocation & location, DeclarationNode * init, OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+#define MISSING_LOW "illegal syntax, missing low value for up-to range so index is uninitialized."
+#define MISSING_HIGH "illegal syntax, missing high value for down-to range so index is uninitialized."
+
+static ForCtrl * makeForCtrl( const CodeLocation & location, DeclarationNode * init, enum OperKinds compop,
+                                                          ExpressionNode * comp, ExpressionNode * inc ) {
         // Wrap both comp/inc if they are non-null.
         if ( comp ) comp = new ExpressionNode( build_binary_val( location,
@@ -242 +243 @@
 }
 
-ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( index->initializer ) {
                 SemanticError( yylloc, "illegal syntax, direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." );
@@ -253 +254 @@
 } // forCtrl
 
-ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, string * index, ExpressionNode * start, OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         ast::ConstantExpr * constant = dynamic_cast<ast::ConstantExpr *>(type->expr.get());
         if ( constant && (constant->rep == "0" || constant->rep == "1") ) {
@@ -267 +268 @@
 #define MISSING_LOOP_INDEX "illegal syntax, only a single identifier or declaration allowed in initialization, e.g., for ( i; ... ) or for ( int i; ... ). Expression disallowed."
 
-ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( auto identifier = dynamic_cast<ast::NameExpr *>(index->expr.get()) ) {
                 return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
+        // } else if ( auto commaExpr = dynamic_cast<ast::CommaExpr *>( index->expr.get() ) ) {
+        //      if ( auto identifier = commaExpr->arg2.as<ast::NameExpr>() ) {
+        //              return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
+        //      } else {
+        //              SemanticError( yylloc, "illegal syntax, loop-index name missing. Expression disallowed." ); return nullptr;
+        //      } // if
         } else {
                 SemanticError( yylloc, MISSING_LOOP_INDEX ); return nullptr;
@@ -275 +282 @@
 } // forCtrl
 
-ForCtrl * enumRangeCtrl( ExpressionNode * index_expr, __attribute__((unused)) OperKinds compop, ExpressionNode * range_over_expr ) {
+ForCtrl * enumRangeCtrl( ExpressionNode * index_expr, ExpressionNode * range_over_expr ) {
         if ( auto identifier = dynamic_cast<ast::NameExpr *>(index_expr->expr.get()) ) {
                 DeclarationNode * indexDecl = DeclarationNode::newName( new std::string(identifier->name) );
                 assert( range_over_expr );
                 return new ForCtrl( new StatementNode( indexDecl ), range_over_expr );
+        // } else if (auto commaExpr = dynamic_cast<ast::CommaExpr *>( index_expr->expr.get() )) {
+        //      if ( auto identifier = commaExpr->arg1.as<ast::NameExpr>() ) {
+        //              assert( range_over_expr );
+        //              DeclarationNode * indexDecl = distAttr(
+        //                      DeclarationNode::newTypeof( range_over_expr, true ),
+        //                      DeclarationNode::newName( new std::string( identifier->name) ) );
+        //              return new ForCtrl( new StatementNode( indexDecl ), range_over_expr );
+        //      } else {
+        //              SemanticError( yylloc, "illegal syntax, loop-index name missing. Comma expression disallowed." ); return nullptr;
+        //      } // if
         } else {
                 SemanticError( yylloc, MISSING_LOOP_INDEX ); return nullptr;
@@ -409 +426 @@
 %token ANDassign        ERassign        ORassign                                // &=   ^=      |=
 
-%token ErangeUp         ErangeUpEq      ErangeDown      ErangeDownEq // +~      +~=/~=  -~      -~=
+%token ErangeUpEq       ErangeDown      ErangeDownEq                    // ~=   -~      -~=
 %token ATassign                                                                                 // @=
 
@@ -1505 +1522 @@
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
 
-                // These rules accept a comma_expression for the initialization, when only an identifier is correct. Being
-                // permissive allows for a better error message from forCtrl.
         | comma_expression ';' comma_expression                         // CFA
                 { $$ = forCtrl( yylloc, $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
@@ -1526 +1541 @@
                 }
         | comma_expression ';' '@' updowneq '@'                         // CFA, invalid syntax rule
-                { SemanticError( yylloc, "illegal syntax, missing low/high value for ascending/descending range so index is uninitialized." ); $$ = nullptr; }
+                { SemanticError( yylloc, "illegal syntax, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
         | comma_expression ';' comma_expression updowneq comma_expression '~' comma_expression // CFA
@@ -1555 +1570 @@
                 }
         | comma_expression ';' '@' updowneq '@' '~' '@' // CFA
-                { SemanticError( yylloc, "illegal syntax, missing low/high value for ascending/descending range so index is uninitialized." ); $$ = nullptr; }
+                { SemanticError( yylloc, "illegal syntax, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
         | declaration comma_expression                                          // CFA
@@ -1603 +1618 @@
                 }
         | declaration '@' updowneq '@' '~' '@'                          // CFA, invalid syntax rule
-                { SemanticError( yylloc, "illegal syntax, missing low/high value for ascending/descending range so index is uninitialized." ); $$ = nullptr; }
+                { SemanticError( yylloc, "illegal syntax, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
         | comma_expression ';' enum_key                                         // CFA, enum type
                 {
-                        $$ = enumRangeCtrl( $1, OperKinds::LEThan, new ExpressionNode( new ast::TypeExpr( yylloc, $3->buildType() ) ) );
+                        $$ = enumRangeCtrl( $1, new ExpressionNode( new ast::TypeExpr( yylloc, $3->buildType() ) ) );
                 }
         | comma_expression ';' downupdowneq enum_key            // CFA, enum type, reverse direction
                 {
-                        if ( $3 == OperKinds::GThan ) {
-                                SemanticError( yylloc, "all enumeration ranges are equal (all values). Add an equal, e.g., ~=, -~=." ); $$ = nullptr;
-                                $3 = OperKinds::GEThan;
-                        } // if
-                        $$ = enumRangeCtrl( $1, $3, new ExpressionNode( new ast::TypeExpr( yylloc, $4->buildType() ) ) );
+                        if ( $3 == OperKinds::LEThan || $3 == OperKinds::GEThan ) {
+                                SemanticError( yylloc, "illegal syntax, all enumeration ranges are equal (all values). Remove \"=~\"." ); $$ = nullptr;
+                        }
+                        SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr;
                 }
         ;
@@ -1628 +1642 @@
         ;
 
-// This rule exists to handle the ambiguity with unary operator '~'. The rule is the same as updowneq minus the '~'.
-// Specifically, "for ( ~5 )" means the complement of 5, not loop 0..4. Hence, in this case "for ( ~= 5 )", i.e., 0..5,
-// it is not possible to just remove the '='. The entire '~=' must be removed.
 downupdowneq:
-        ErangeUp
-                { $$ = OperKinds::LThan; }
-        | ErangeDown
+        ErangeDown
                 { $$ = OperKinds::GThan; }
         | ErangeUpEq
@@ -1643 +1652 @@
 
 updown:
-        '~'                                                                                                     // shorthand 0 ~ 10 => 0 +~ 10
-                { $$ = OperKinds::LThan; }
-        | ErangeUp
+        '~'
                 { $$ = OperKinds::LThan; }
         | ErangeDown