Changeset bc07190 for src/Parser


Ignore:
Timestamp:
Jun 29, 2024, 7:33:28 AM (19 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
master
Children:
011c29e
Parents:
62a38e7 (diff), 115ac1ce (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
src/Parser
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/StatementNode.cpp

    r62a38e7 rbc07190  
    216216                return new ast::ForStmt( location,
    217217                        std::move( astinit ),
    218                         range_over,
     218                        range_over, forctl->kind == OperKinds::LThan,
    219219                        buildMoveSingle( stmt ),
    220220                        buildMoveOptional( else_ )

  • src/Parser/StatementNode.hpp

    r62a38e7 rbc07190  
    6464        ForCtrl( StatementNode * stmt, ExpressionNode * condition, ExpressionNode * change ) :
    6565                init( stmt ), condition( condition ), change( change ), range_over( nullptr ) {}
    66         ForCtrl( StatementNode * decl, ExpressionNode * _range_over) :
    67                 init( decl ), condition( nullptr ), change( nullptr ),  range_over( _range_over ) {}
     66        ForCtrl( StatementNode * decl, ExpressionNode * range_over, OperKinds kind ) :
     67                init( decl ), condition( nullptr ), change( nullptr ),  range_over( range_over ), kind( kind ) {}
    6868
    6969        StatementNode * init;
    … …  
    7171        ExpressionNode * change;
    7272        ExpressionNode * range_over;
     73        OperKinds kind;
    7374};
    7475

  • src/Parser/TypeData.cpp

    r62a38e7 rbc07190  
    14691469                ast::ObjectDecl * object = strict_dynamic_cast<ast::ObjectDecl *>( member );
    14701470                object->isHidden = ast::EnumDecl::EnumHiding::Hide == ret->hide;
    1471                 if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
    1472                         SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
     1471                if ( ret->isOpague() && cur->has_enumeratorValue() ) {
     1472                        SemanticError( td->location, "Opague cannot have an explicit initializer value." );
    14731473                } else if ( cur->has_enumeratorValue() ) {
    14741474                        object->init = new ast::SingleInit(

  • src/Parser/lex.ll

    r62a38e7 rbc07190  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Thu Jun 20 16:54:05 2024
    13  * Update Count     : 778
     12 * Last Modified On : Thu Jun 27 14:38:27 2024
     13 * Update Count     : 780
    1414 */
    1515
    … …  
    458458
    459459"@="                    { NAMEDOP_RETURN(ATassign); }                   // CFA
     460"+~"                    { NAMEDOP_RETURN(ErangeUp); }                   // CFA
    460461"~="                    { NAMEDOP_RETURN(ErangeUpEq); }                 // CFA
     462"+~="                   { NAMEDOP_RETURN(ErangeUpEq); }                 // CFA
    461463"-~"                    { NAMEDOP_RETURN(ErangeDown); }                 // CFA
    462464"-~="                   { NAMEDOP_RETURN(ErangeDownEq); }               // CFA

  • src/Parser/parser.yy

    r62a38e7 rbc07190  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jun 24 22:45:20 2024
    13 // Update Count     : 6684
     12// Last Modified On : Thu Jun 27 14:45:57 2024
     13// Update Count     : 6705
    1414//
    1515
    … …  
    224224#define UPDOWN( compop, left, right ) (compop == OperKinds::LThan || compop == OperKinds::LEThan ? left : right)
    225225#define MISSING_ANON_FIELD "illegal syntax, missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body."
    226 #define MISSING_LOW "illegal syntax, missing low value for up-to range so index is uninitialized."
    227 #define MISSING_HIGH "illegal syntax, missing high value for down-to range so index is uninitialized."
    228 
    229 static ForCtrl * makeForCtrl( const CodeLocation & location, DeclarationNode * init, enum OperKinds compop,
    230                                                           ExpressionNode * comp, ExpressionNode * inc ) {
     226#define MISSING_LOW "illegal syntax, missing low value for ascanding range so index is uninitialized."
     227#define MISSING_HIGH "illegal syntax, missing high value for descending range so index is uninitialized."
     228
     229static ForCtrl * makeForCtrl( const CodeLocation & location, DeclarationNode * init, OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
    231230        // Wrap both comp/inc if they are non-null.
    232231        if ( comp ) comp = new ExpressionNode( build_binary_val( location,
    … …  
    243242}
    244243
    245 ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
     244ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
    246245        if ( index->initializer ) {
    247246                SemanticError( yylloc, "illegal syntax, direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." );
    … …  
    254253} // forCtrl
    255254
    256 ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
     255ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, string * index, ExpressionNode * start, OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
    257256        ast::ConstantExpr * constant = dynamic_cast<ast::ConstantExpr *>(type->expr.get());
    258257        if ( constant && (constant->rep == "0" || constant->rep == "1") ) {
    … …  
    268267#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."
    269268
    270 ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
     269ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
    271270        if ( auto identifier = dynamic_cast<ast::NameExpr *>(index->expr.get()) ) {
    272271                return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
    273         // } else if ( auto commaExpr = dynamic_cast<ast::CommaExpr *>( index->expr.get() ) ) {
    274         //      if ( auto identifier = commaExpr->arg2.as<ast::NameExpr>() ) {
    275         //              return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
    276         //      } else {
    277         //              SemanticError( yylloc, "illegal syntax, loop-index name missing. Expression disallowed." ); return nullptr;
    278         //      } // if
    279272        } else {
    280273                SemanticError( yylloc, MISSING_LOOP_INDEX ); return nullptr;
    … …  
    282275} // forCtrl
    283276
    284 ForCtrl * enumRangeCtrl( ExpressionNode * index_expr, ExpressionNode * range_over_expr ) {
     277ForCtrl * enumRangeCtrl( ExpressionNode * index_expr, __attribute__((unused)) OperKinds compop, ExpressionNode * range_over_expr ) {
    285278        if ( auto identifier = dynamic_cast<ast::NameExpr *>(index_expr->expr.get()) ) {
    286279                DeclarationNode * indexDecl = DeclarationNode::newName( new std::string(identifier->name) );
    287280                assert( range_over_expr );
    288                 return new ForCtrl( new StatementNode( indexDecl ), range_over_expr );
    289         // } else if (auto commaExpr = dynamic_cast<ast::CommaExpr *>( index_expr->expr.get() )) {
    290         //      if ( auto identifier = commaExpr->arg1.as<ast::NameExpr>() ) {
    291         //              assert( range_over_expr );
    292         //              DeclarationNode * indexDecl = distAttr(
    293         //                      DeclarationNode::newTypeof( range_over_expr, true ),
    294         //                      DeclarationNode::newName( new std::string( identifier->name) ) );
    295         //              return new ForCtrl( new StatementNode( indexDecl ), range_over_expr );
    296         //      } else {
    297         //              SemanticError( yylloc, "illegal syntax, loop-index name missing. Comma expression disallowed." ); return nullptr;
    298         //      } // if
     281                return new ForCtrl( new StatementNode( indexDecl ), range_over_expr, compop );
    299282        } else {
    300283                SemanticError( yylloc, MISSING_LOOP_INDEX ); return nullptr;
    … …  
    426409%token ANDassign        ERassign        ORassign                                // &=   ^=      |=
    427410
    428 %token ErangeUpEq       ErangeDown      ErangeDownEq                    // ~=   -~      -~=
     411%token ErangeUp         ErangeUpEq      ErangeDown      ErangeDownEq // +~      +~=/~=  -~      -~=
    429412%token ATassign                                                                                 // @=
    430413
    … …  
    15221505                { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
    15231506
     1507                // These rules accept a comma_expression for the initialization, when only an identifier is correct. Being
     1508                // permissive allows for a better error message from forCtrl.
    15241509        | comma_expression ';' comma_expression                         // CFA
    15251510                { $$ = forCtrl( yylloc, $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
    … …  
    15411526                }
    15421527        | comma_expression ';' '@' updowneq '@'                         // CFA, invalid syntax rule
    1543                 { SemanticError( yylloc, "illegal syntax, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
     1528                { SemanticError( yylloc, "illegal syntax, missing low/high value for ascending/descending range so index is uninitialized." ); $$ = nullptr; }
    15441529
    15451530        | comma_expression ';' comma_expression updowneq comma_expression '~' comma_expression // CFA
    … …  
    15701555                }
    15711556        | comma_expression ';' '@' updowneq '@' '~' '@' // CFA
    1572                 { SemanticError( yylloc, "illegal syntax, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
     1557                { SemanticError( yylloc, "illegal syntax, missing low/high value for ascending/descending range so index is uninitialized." ); $$ = nullptr; }
    15731558
    15741559        | declaration comma_expression                                          // CFA
    … …  
    16181603                }
    16191604        | declaration '@' updowneq '@' '~' '@'                          // CFA, invalid syntax rule
    1620                 { SemanticError( yylloc, "illegal syntax, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
     1605                { SemanticError( yylloc, "illegal syntax, missing low/high value for ascending/descending range so index is uninitialized." ); $$ = nullptr; }
    16211606
    16221607        | comma_expression ';' enum_key                                         // CFA, enum type
    16231608                {
    1624                         $$ = enumRangeCtrl( $1, new ExpressionNode( new ast::TypeExpr( yylloc, $3->buildType() ) ) );
     1609                        $$ = enumRangeCtrl( $1, OperKinds::LEThan, new ExpressionNode( new ast::TypeExpr( yylloc, $3->buildType() ) ) );
    16251610                }
    16261611        | comma_expression ';' downupdowneq enum_key            // CFA, enum type, reverse direction
    16271612                {
    1628                         if ( $3 == OperKinds::LEThan || $3 == OperKinds::GEThan ) {
    1629                                 SemanticError( yylloc, "illegal syntax, all enumeration ranges are equal (all values). Remove \"=~\"." ); $$ = nullptr;
    1630                         }
    1631                         SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr;
     1613                        if ( $3 == OperKinds::GThan ) {
     1614                                SemanticError( yylloc, "all enumeration ranges are equal (all values). Add an equal, e.g., ~=, -~=." ); $$ = nullptr;
     1615                                $3 = OperKinds::GEThan;
     1616                        } // if
     1617                        $$ = enumRangeCtrl( $1, $3, new ExpressionNode( new ast::TypeExpr( yylloc, $4->buildType() ) ) );
    16321618                }
    16331619        ;
    … …  
    16421628        ;
    16431629
     1630// This rule exists to handle the ambiguity with unary operator '~'. The rule is the same as updowneq minus the '~'.
     1631// Specifically, "for ( ~5 )" means the complement of 5, not loop 0..4. Hence, in this case "for ( ~= 5 )", i.e., 0..5,
     1632// it is not possible to just remove the '='. The entire '~=' must be removed.
    16441633downupdowneq:
    1645         ErangeDown
     1634        ErangeUp
     1635                { $$ = OperKinds::LThan; }
     1636        | ErangeDown
    16461637                { $$ = OperKinds::GThan; }
    16471638        | ErangeUpEq
    … …  
    16521643
    16531644updown:
    1654         '~'
     1645        '~'                                                                                                     // shorthand 0 ~ 10 => 0 +~ 10
     1646                { $$ = OperKinds::LThan; }
     1647        | ErangeUp
    16551648                { $$ = OperKinds::LThan; }
    16561649        | ErangeDown
Note: See TracChangeset for help on using the changeset viewer.