Changeset 089b39e1 for src

Timestamp:

Jun 25, 2024, 9:25:50 PM (10 days ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

343c8be

Parents:

5eb3f65

Message:

clean up, prepare for downto enumerating

File:

• src/Parser/parser.yy (modified) (9 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 : Mon Jun 24 22:45:20 2024
-// Update Count     : 6684
+// Last Modified On : Tue Jun 25 18:44:14 2024
+// Update Count     : 6692
 //
 
@@ -227 +227 @@
 #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 ) {
+static ForCtrl * makeForCtrl( const CodeLocation & location, DeclarationNode * init, OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         // Wrap both comp/inc if they are non-null.
         if ( comp ) comp = new ExpressionNode( build_binary_val( location,
@@ -243 +242 @@
 }
 
-ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( index->initializer ) {
                 SemanticError( yylloc, "illegal syntax, direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." );
@@ -254 +253 @@
 } // forCtrl
 
-ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, string * index, ExpressionNode * start, OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         ast::ConstantExpr * constant = dynamic_cast<ast::ConstantExpr *>(type->expr.get());
         if ( constant && (constant->rep == "0" || constant->rep == "1") ) {
@@ -268 +267 @@
 #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, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, 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;
@@ -282 +275 @@
 } // forCtrl
 
-ForCtrl * enumRangeCtrl( ExpressionNode * index_expr, ExpressionNode * range_over_expr ) {
+ForCtrl * enumRangeCtrl( ExpressionNode * index_expr, __attribute__((unused)) OperKinds compop, 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;
@@ -1522 +1505 @@
                 { 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 ); }
@@ -1622 +1607 @@
         | comma_expression ';' enum_key                                         // CFA, enum type
                 {
-                        $$ = enumRangeCtrl( $1, new ExpressionNode( new ast::TypeExpr( yylloc, $3->buildType() ) ) );
+                        $$ = enumRangeCtrl( $1, OperKinds::LThan, new ExpressionNode( new ast::TypeExpr( yylloc, $3->buildType() ) ) );
                 }
         | comma_expression ';' downupdowneq enum_key            // CFA, enum type, reverse direction
@@ -1629 +1614 @@
                                 SemanticError( yylloc, "illegal syntax, all enumeration ranges are equal (all values). Remove \"=~\"." ); $$ = nullptr;
                         }
-                        SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr;
+                        $$ = enumRangeCtrl( $1, $3, new ExpressionNode( new ast::TypeExpr( yylloc, $4->buildType() ) ) );
                 }
         ;