Changeset 033ff37


Ignore:
Timestamp:
Jul 26, 2019, 6:39:42 AM (2 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
be53b87
Parents:
f673c13
Message:

remove attribute expression '@'name mechanism

Files:
1 deleted
15 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Convert.cpp

    rf673c13 r033ff37  
    99// Author           : Thierry Delisle
    1010// Created On       : Thu May 09 15::37::05 2019
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Jun 17 16:44:00 2019
    13 // Update Count     : 12
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Jul 25 22:21:46 2019
     13// Update Count     : 13
    1414//
    1515
     
    26762676                );
    26772677        }
    2678 
    2679         virtual void visit( const AttrExpr * ) override final {
    2680                 assertf( false, "AttrExpr deprecated in new AST." );
    2681         }
    26822678};
    26832679
  • src/AST/porting.md

    rf673c13 r033ff37  
    171171  * all existing uses assume `type` set if true and don't use `expr`
    172172
    173 `AttrExpr`
    174 * did not port due to feature deprecation (e.g. `expr@attribute`)
    175 
    176173`LogicalExpr`
    177174* un-defaulted constructor parameter determining `&&` or `||`
  • src/Common/PassVisitor.h

    rf673c13 r033ff37  
    155155        virtual void visit( OffsetPackExpr * offsetPackExpr ) override final;
    156156        virtual void visit( const OffsetPackExpr * offsetPackExpr ) override final;
    157         virtual void visit( AttrExpr * attrExpr ) override final;
    158         virtual void visit( const AttrExpr * attrExpr ) override final;
    159157        virtual void visit( LogicalExpr * logicalExpr ) override final;
    160158        virtual void visit( const LogicalExpr * logicalExpr ) override final;
     
    301299        virtual Expression * mutate( OffsetofExpr * offsetofExpr ) override final;
    302300        virtual Expression * mutate( OffsetPackExpr * offsetPackExpr ) override final;
    303         virtual Expression * mutate( AttrExpr * attrExpr ) override final;
    304301        virtual Expression * mutate( LogicalExpr * logicalExpr ) override final;
    305302        virtual Expression * mutate( ConditionalExpr * conditionalExpr ) override final;
  • src/Common/PassVisitor.impl.h

    rf673c13 r033ff37  
    23022302
    23032303//--------------------------------------------------------------------------
    2304 // AttrExpr
    2305 template< typename pass_type >
    2306 void PassVisitor< pass_type >::visit( AttrExpr * node ) {
    2307         VISIT_START( node );
    2308 
    2309         indexerScopedAccept( node->result, *this );
    2310         if ( node->get_isType() ) {
    2311                 maybeAccept_impl( node->type, *this );
    2312         } else {
    2313                 maybeAccept_impl( node->expr, *this );
    2314         }
    2315 
    2316         VISIT_END( node );
    2317 }
    2318 
    2319 template< typename pass_type >
    2320 void PassVisitor< pass_type >::visit( const AttrExpr * node ) {
    2321         VISIT_START( node );
    2322 
    2323         indexerScopedAccept( node->result, *this );
    2324         if ( node->get_isType() ) {
    2325                 maybeAccept_impl( node->type, *this );
    2326         } else {
    2327                 maybeAccept_impl( node->expr, *this );
    2328         }
    2329 
    2330         VISIT_END( node );
    2331 }
    2332 
    2333 template< typename pass_type >
    2334 Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
    2335         MUTATE_START( node );
    2336 
    2337         indexerScopedMutate( node->env   , *this );
    2338         indexerScopedMutate( node->result, *this );
    2339         if ( node->get_isType() ) {
    2340                 maybeMutate_impl( node->type, *this );
    2341         } else {
    2342                 maybeMutate_impl( node->expr, *this );
    2343         }
    2344 
    2345         MUTATE_END( Expression, node );
    2346 }
    2347 
    2348 //--------------------------------------------------------------------------
    23492304// LogicalExpr
    23502305template< typename pass_type >
  • src/InitTweak/InitTweak.cc

    rf673c13 r033ff37  
    99// Author           : Rob Schluntz
    1010// Created On       : Fri May 13 11:26:36 2016
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jun 19 14:34:00 2019
    13 // Update Count     : 6
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Jul 25 22:21:48 2019
     13// Update Count     : 7
    1414//
    1515
     
    957957                void previsit( OffsetofExpr * ) {}
    958958                void previsit( OffsetPackExpr * ) {}
    959                 void previsit( AttrExpr * ) {}
    960959                void previsit( CommaExpr * ) {}
    961960                void previsit( LogicalExpr * ) {}
  • src/Parser/DeclarationNode.cc

    rf673c13 r033ff37  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul 25 17:13:06 2019
    13 // Update Count     : 1115
     12// Last Modified On : Thu Jul 25 22:17:10 2019
     13// Update Count     : 1116
    1414//
    1515
     
    418418        return newnode;
    419419} // DeclarationNode::newBuiltinType
    420 
    421 DeclarationNode * DeclarationNode::newAttr( const string * name, ExpressionNode * expr ) {
    422         DeclarationNode * newnode = new DeclarationNode;
    423         newnode->type = nullptr;
    424 //      newnode->attr.name = name;
    425         newnode->name = name;
    426         newnode->attr.expr = expr;
    427         return newnode;
    428 }
    429 
    430 DeclarationNode * DeclarationNode::newAttr( const string * name, DeclarationNode * type ) {
    431         DeclarationNode * newnode = new DeclarationNode;
    432         newnode->type = nullptr;
    433 //      newnode->attr.name = name;
    434         newnode->name = name;
    435         newnode->attr.type = type;
    436         return newnode;
    437 }
    438420
    439421DeclarationNode * DeclarationNode::newAttribute( const string * name, ExpressionNode * expr ) {
  • src/Parser/ParseNode.h

    rf673c13 r033ff37  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul 25 15:49:51 2019
    13 // Update Count     : 875
     12// Last Modified On : Thu Jul 25 22:17:10 2019
     13// Update Count     : 876
    1414//
    1515
     
    252252        static DeclarationNode * newTuple( DeclarationNode * members );
    253253        static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
    254         static DeclarationNode * newAttr( const std::string *, ExpressionNode * expr ); // @ attributes
    255         static DeclarationNode * newAttr( const std::string *, DeclarationNode * type ); // @ attributes
    256254        static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
    257255        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
  • src/Parser/lex.ll

    rf673c13 r033ff37  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Thu Jul 25 15:46:05 2019
    13  * Update Count     : 715
     12 * Last Modified On : Thu Jul 25 22:08:32 2019
     13 * Update Count     : 716
    1414 */
    1515
     
    5959#define QKEYWORD_RETURN(x)      RETURN_VAL(x);                          // quasi-keyword
    6060#define IDENTIFIER_RETURN()     RETURN_VAL( typedefTable.isKind( yytext ) )
    61 #define ATTRIBUTE_RETURN()      RETURN_VAL( ATTR_IDENTIFIER )
    6261
    6362#ifdef HAVE_KEYWORDS_FLOATXX                                                            // GCC >= 7 => keyword, otherwise typedef
     
    9291                                // identifier, GCC: $ in identifier
    9392identifier ([a-zA-Z_$]|{universal_char})([0-9a-zA-Z_$]|{universal_char})*
    94 
    95                                 // attribute identifier, GCC: $ in identifier
    96 attr_identifier "@"{identifier}
    9793
    9894                                // numeric constants, CFA: '_' in constant
     
    336332        IDENTIFIER_RETURN();
    337333}
    338 {attr_identifier} { ATTRIBUTE_RETURN(); }
    339334
    340335                                /* numeric constants */
  • src/Parser/parser.yy

    rf673c13 r033ff37  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul 25 15:49:52 2019
    13 // Update Count     : 4356
     12// Last Modified On : Thu Jul 25 22:31:38 2019
     13// Update Count     : 4359
    1414//
    1515
     
    289289%token<tok> IDENTIFIER                  QUOTED_IDENTIFIER               TYPEDEFname                             TYPEGENname
    290290%token<tok> TIMEOUT                             WOR
    291 %token<tok> ATTR_IDENTIFIER             ATTR_TYPEDEFname                ATTR_TYPEGENname
    292291%token<tok> INTEGERconstant             CHARACTERconstant               STRINGliteral
    293292%token<tok> DIRECTIVE
     
    313312%token ATassign                                                                                 // @=
    314313
    315 %type<tok> identifier  no_attr_identifier
    316 %type<tok> identifier_or_type_name  no_attr_identifier_or_type_name  attr_name
     314%type<tok> identifier
     315%type<tok> identifier_or_type_name  attr_name
    317316%type<tok> quasi_keyword
    318317%type<constant> string_literal
     
    547546        ;
    548547
    549 no_attr_identifier:
     548identifier:
    550549        IDENTIFIER
    551550        | quasi_keyword
    552551        | '@'                                                                                           // CFA
    553552                { Token tok = { new string( DeclarationNode::anonymous.newName() ), yylval.tok.loc }; $$ = tok; }
    554         ;
    555 
    556 identifier:
    557         no_attr_identifier
    558         | ATTR_IDENTIFIER                                                                       // CFA
    559553        ;
    560554
     
    595589        | '(' comma_expression ')' '`' IDENTIFIER                       // CFA, postfix call
    596590                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $5 ) ), $2 ) ); }
    597         | type_name '.' no_attr_identifier                                      // CFA, nested type
     591        | type_name '.' identifier                                                      // CFA, nested type
    598592                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
    599593        | type_name '.' '[' field_name_list ']'                         // CFA, nested type / tuple field selector
     
    648642        | postfix_expression '(' argument_expression_list ')'
    649643                { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
    650         | postfix_expression '.' no_attr_identifier
     644        | postfix_expression '.' identifier
    651645                { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
    652646        | postfix_expression '.' INTEGERconstant                        // CFA, tuple index
     
    656650        | postfix_expression '.' '[' field_name_list ']'        // CFA, tuple field selector
    657651                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
    658         | postfix_expression ARROW no_attr_identifier
     652        | postfix_expression ARROW identifier
    659653                { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
    660654        | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
     
    719713        | FLOATINGconstant fraction_constants_opt
    720714                { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
    721         | no_attr_identifier fraction_constants_opt
     715        | identifier fraction_constants_opt
    722716                {
    723717                        $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
     
    777771        | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
    778772                { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuildType( $3 ) ) ); }
    779         | OFFSETOF '(' type_no_function ',' no_attr_identifier ')'
     773        | OFFSETOF '(' type_no_function ',' identifier ')'
    780774                { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
    781         | ATTR_IDENTIFIER
    782                 { $$ = new ExpressionNode( new AttrExpr( build_varref( $1 ), maybeMoveBuild< Expression >( (ExpressionNode *)nullptr ) ) ); }
    783         | ATTR_IDENTIFIER '(' argument_expression ')'
    784                 { $$ = new ExpressionNode( new AttrExpr( build_varref( $1 ), maybeMoveBuild< Expression >( $3 ) ) ); }
    785         | ATTR_IDENTIFIER '(' type ')'
    786                 { $$ = new ExpressionNode( new AttrExpr( build_varref( $1 ), maybeMoveBuildType( $3 ) ) ); }
    787775        ;
    788776
     
    10191007
    10201008labeled_statement:
    1021                 // labels cannot be identifiers 0 or 1 or ATTR_IDENTIFIER
     1009                // labels cannot be identifiers 0 or 1
    10221010        identifier_or_type_name ':' attribute_list_opt statement
    10231011                { $$ = $4->add_label( $1, $3 ); }
     
    13871375        | type_specifier_nobody variable_abstract_declarator
    13881376                { $$ = $2->addType( $1 ); }
    1389         | cfa_abstract_declarator_tuple no_attr_identifier      // CFA
     1377        | cfa_abstract_declarator_tuple identifier                      // CFA
    13901378                { $$ = $1->addName( $2 ); }
    13911379        | cfa_abstract_declarator_tuple                                         // CFA
     
    14511439
    14521440label_list:
    1453         no_attr_identifier
     1441        identifier
    14541442                {
    14551443                        $$ = new LabelNode(); $$->labels.push_back( *$1 );
    14561444                        delete $1;                                                                      // allocated by lexer
    14571445                }
    1458         | label_list ',' no_attr_identifier
     1446        | label_list ',' identifier
    14591447                {
    14601448                        $$ = $1; $1->labels.push_back( *$3 );
     
    15011489
    15021490local_label_list:                                                                               // GCC, local label
    1503         no_attr_identifier_or_type_name
    1504         | local_label_list ',' no_attr_identifier_or_type_name
     1491        identifier_or_type_name
     1492        | local_label_list ',' identifier_or_type_name
    15051493        ;
    15061494
     
    16241612                        $$ = $2->addTypedef();
    16251613                }
    1626         | cfa_typedef_declaration pop ',' push no_attr_identifier
     1614        | cfa_typedef_declaration pop ',' push identifier
    16271615                {
    16281616                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname, "3" );
     
    16641652typedef_expression:
    16651653                // GCC, naming expression type: typedef name = exp; gives a name to the type of an expression
    1666         TYPEDEF no_attr_identifier '=' assignment_expression
     1654        TYPEDEF identifier '=' assignment_expression
    16671655                {
    16681656                        // $$ = DeclarationNode::newName( 0 );                  // unimplemented
    16691657                        SemanticError( yylloc, "Typedef expression is currently unimplemented." ); $$ = nullptr;
    16701658                }
    1671         | typedef_expression pop ',' push no_attr_identifier '=' assignment_expression
     1659        | typedef_expression pop ',' push identifier '=' assignment_expression
    16721660                {
    16731661                        // $$ = DeclarationNode::newName( 0 );                  // unimplemented
     
    19151903        | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
    19161904                { $$ = DeclarationNode::newTypeof( $3, true ); }
    1917         | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type( x ) y;
    1918                 { $$ = DeclarationNode::newAttr( $1, $3 ); }
    1919         | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type( a+b ) y;
    1920                 { $$ = DeclarationNode::newAttr( $1, $3 ); }
    19211905        | ZERO_T                                                                                        // CFA
    19221906                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
     
    20272011          '{' field_declaration_list_opt '}' type_parameters_opt
    20282012                { $$ = DeclarationNode::newAggregate( $1, nullptr, $7, $5, true )->addQualifiers( $2 ); }
    2029         | aggregate_key attribute_list_opt no_attr_identifier fred
     2013        | aggregate_key attribute_list_opt identifier fred
    20302014                {
    20312015                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
     
    20532037
    20542038aggregate_type_nobody:                                                                  // struct, union - {...}
    2055         aggregate_key attribute_list_opt no_attr_identifier fred
     2039        aggregate_key attribute_list_opt identifier fred
    20562040                {
    20572041                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname );
     
    21542138cfa_field_declaring_list:                                                               // CFA, new style field declaration
    21552139        // bit-fields are handled by C declarations
    2156         cfa_abstract_declarator_tuple no_attr_identifier_or_type_name
     2140        cfa_abstract_declarator_tuple identifier_or_type_name
    21572141                { $$ = $1->addName( $2 ); }
    2158         | cfa_field_declaring_list ',' no_attr_identifier_or_type_name
     2142        | cfa_field_declaring_list ',' identifier_or_type_name
    21592143                { $$ = $1->appendList( $1->cloneType( $3 ) ); }
    21602144        ;
     
    21812165        ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
    21822166                { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
    2183         | ENUM attribute_list_opt no_attr_identifier
     2167        | ENUM attribute_list_opt identifier
    21842168                { typedefTable.makeTypedef( *$3 ); }
    21852169          '{' enumerator_list comma_opt '}'
     
    21922176
    21932177enum_type_nobody:                                                                               // enum - {...}
    2194         ENUM attribute_list_opt no_attr_identifier
     2178        ENUM attribute_list_opt identifier
    21952179                {
    21962180                        typedefTable.makeTypedef( *$3 );
     
    22052189
    22062190enumerator_list:
    2207         no_attr_identifier_or_type_name enumerator_value_opt
     2191        identifier_or_type_name enumerator_value_opt
    22082192                { $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
    2209         | enumerator_list ',' no_attr_identifier_or_type_name enumerator_value_opt
     2193        | enumerator_list ',' identifier_or_type_name enumerator_value_opt
    22102194                { $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
    22112195        ;
     
    23152299
    23162300identifier_list:                                                                                // K&R-style parameter list => no types
    2317         no_attr_identifier
     2301        identifier
    23182302                { $$ = DeclarationNode::newName( $1 ); }
    2319         | identifier_list ',' no_attr_identifier
     2303        | identifier_list ',' identifier
    23202304                { $$ = $1->appendList( DeclarationNode::newName( $3 ) ); }
    23212305        ;
     
    23232307identifier_or_type_name:
    23242308        identifier
    2325         | TYPEDEFname
    2326         | TYPEGENname
    2327         ;
    2328 
    2329 no_attr_identifier_or_type_name:
    2330         no_attr_identifier
    23312309        | TYPEDEFname
    23322310        | TYPEGENname
     
    23832361designation:
    23842362        designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
    2385         | no_attr_identifier ':'                                                        // GCC, field name
     2363        | identifier ':'                                                                        // GCC, field name
    23862364                { $$ = new ExpressionNode( build_varref( $1 ) ); }
    23872365        ;
     
    23952373
    23962374designator:
    2397         '.' no_attr_identifier                                                          // C99, field name
     2375        '.' identifier                                                                          // C99, field name
    23982376                { $$ = new ExpressionNode( build_varref( $2 ) ); }
    23992377        | '[' push assignment_expression pop ']'                        // C99, single array element
     
    24402418
    24412419type_parameter:                                                                                 // CFA
    2442         type_class no_attr_identifier_or_type_name
     2420        type_class identifier_or_type_name
    24432421                { typedefTable.addToScope( *$2, TYPEDEFname, "9" ); }
    24442422          type_initializer_opt assertion_list_opt
     
    24732451
    24742452assertion:                                                                                              // CFA
    2475         '|' no_attr_identifier_or_type_name '(' type_list ')'
     2453        '|' identifier_or_type_name '(' type_list ')'
    24762454                { $$ = DeclarationNode::newTraitUse( $2, $4 ); }
    24772455        | '|' '{' push trait_declaration_list pop '}'
     
    25102488
    25112489type_declarator_name:                                                                   // CFA
    2512         no_attr_identifier_or_type_name
     2490        identifier_or_type_name
    25132491                {
    25142492                        typedefTable.addToEnclosingScope( *$1, TYPEDEFname, "10" );
    25152493                        $$ = DeclarationNode::newTypeDecl( $1, 0 );
    25162494                }
    2517         | no_attr_identifier_or_type_name '(' type_parameter_list ')'
     2495        | identifier_or_type_name '(' type_parameter_list ')'
    25182496                {
    25192497                        typedefTable.addToEnclosingScope( *$1, TYPEGENname, "11" );
     
    25232501
    25242502trait_specifier:                                                                                // CFA
    2525         TRAIT no_attr_identifier_or_type_name '(' type_parameter_list ')' '{' '}'
     2503        TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' '}'
    25262504                { $$ = DeclarationNode::newTrait( $2, $4, 0 ); }
    2527         | TRAIT no_attr_identifier_or_type_name '(' type_parameter_list ')' '{' push trait_declaration_list pop '}'
     2505        | TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' push trait_declaration_list pop '}'
    25282506                { $$ = DeclarationNode::newTrait( $2, $4, $8 ); }
    25292507        ;
  • src/ResolvExpr/AlternativeFinder.cc

    rf673c13 r033ff37  
    1010// Created On       : Sat May 16 23:52:08 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Nov  1 21:00:56 2018
    13 // Update Count     : 35
     12// Last Modified On : Thu Jul 25 22:37:46 2019
     13// Update Count     : 37
    1414//
    1515
     
    7979                void postvisit( OffsetofExpr * offsetofExpr );
    8080                void postvisit( OffsetPackExpr * offsetPackExpr );
    81                 void postvisit( AttrExpr * attrExpr );
    8281                void postvisit( LogicalExpr * logicalExpr );
    8382                void postvisit( ConditionalExpr * conditionalExpr );
     
    14041403        }
    14051404
    1406         namespace {
    1407                 void resolveAttr( SymTab::Indexer::IdData data, const FunctionType * function, Type * argType, const TypeEnvironment &env, AlternativeFinder & finder ) {
    1408                         // assume no polymorphism
    1409                         // assume no implicit conversions
    1410                         assert( function->parameters.size() == 1 );
    1411                         PRINT(
    1412                                 std::cerr << "resolvAttr: funcDecl is ";
    1413                                 data.id->print( std::cerr );
    1414                                 std::cerr << " argType is ";
    1415                                 argType->print( std::cerr );
    1416                                 std::cerr << std::endl;
    1417                         )
    1418                         const SymTab::Indexer & indexer = finder.get_indexer();
    1419                         AltList & alternatives = finder.get_alternatives();
    1420                         if ( typesCompatibleIgnoreQualifiers( argType, function->parameters.front()->get_type(), indexer, env ) ) {
    1421                                 Cost cost = Cost::zero;
    1422                                 Expression * newExpr = data.combine( cost );
    1423                                 alternatives.push_back( Alternative{
    1424                                         new AttrExpr{ newExpr, argType->clone() }, env, OpenVarSet{},
    1425                                         AssertionList{}, Cost::zero, cost } );
    1426                                 for ( DeclarationWithType * retVal : function->returnVals ) {
    1427                                         alternatives.back().expr->result = retVal->get_type()->clone();
    1428                                 } // for
    1429                         } // if
    1430                 }
    1431         }
    1432 
    1433         void AlternativeFinder::Finder::postvisit( AttrExpr * attrExpr ) {
    1434                 // assume no 'pointer-to-attribute'
    1435                 NameExpr * nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() );
    1436                 assert( nameExpr );
    1437                 std::list< SymTab::Indexer::IdData > attrList;
    1438                 indexer.lookupId( nameExpr->get_name(), attrList );
    1439                 if ( attrExpr->get_isType() || attrExpr->get_expr() ) {
    1440                         for ( auto & data : attrList ) {
    1441                                 const DeclarationWithType * id = data.id;
    1442                                 // check if the type is function
    1443                                 if ( const FunctionType * function = dynamic_cast< const FunctionType * >( id->get_type() ) ) {
    1444                                         // assume exactly one parameter
    1445                                         if ( function->parameters.size() == 1 ) {
    1446                                                 if ( attrExpr->get_isType() ) {
    1447                                                         resolveAttr( data, function, attrExpr->get_type(), env, altFinder);
    1448                                                 } else {
    1449                                                         AlternativeFinder finder( indexer, env );
    1450                                                         finder.find( attrExpr->get_expr() );
    1451                                                         for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
    1452                                                                 if ( choice->expr->get_result()->size() == 1 ) {
    1453                                                                         resolveAttr(data, function, choice->expr->get_result(), choice->env, altFinder );
    1454                                                                 } // fi
    1455                                                         } // for
    1456                                                 } // if
    1457                                         } // if
    1458                                 } // if
    1459                         } // for
    1460                 } else {
    1461                         for ( auto & data : attrList ) {
    1462                                 Cost cost = Cost::zero;
    1463                                 Expression * newExpr = data.combine( cost );
    1464                                 alternatives.push_back( Alternative{
    1465                                         newExpr, env, OpenVarSet{}, AssertionList{}, Cost::zero, cost } );
    1466                                 renameTypes( alternatives.back().expr );
    1467                         } // for
    1468                 } // if
    1469         }
    1470 
    14711405        void AlternativeFinder::Finder::postvisit( LogicalExpr * logicalExpr ) {
    14721406                AlternativeFinder firstFinder( indexer, env );
  • src/SynTree/Expression.cc

    rf673c13 r033ff37  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb 19 18:10:55 2019
    13 // Update Count     : 60
     12// Last Modified On : Thu Jul 25 22:21:48 2019
     13// Update Count     : 61
    1414//
    1515
     
    249249        os << "Offset pack expression on ";
    250250        type->print(os, indent+1);
    251         Expression::print( os, indent );
    252 }
    253 
    254 AttrExpr::AttrExpr( Expression * attr, Expression * expr_ ) :
    255                 Expression(), attr( attr ), expr(expr_), type(0), isType(false) {
    256 }
    257 
    258 AttrExpr::AttrExpr( Expression * attr, Type * type_ ) :
    259                 Expression(), attr( attr ), expr(0), type(type_), isType(true) {
    260 }
    261 
    262 AttrExpr::AttrExpr( const AttrExpr & other ) :
    263                 Expression( other ), attr( maybeClone( other.attr ) ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
    264 }
    265 
    266 AttrExpr::~AttrExpr() {
    267         delete attr;
    268         delete expr;
    269         delete type;
    270 }
    271 
    272 void AttrExpr::print( std::ostream & os, Indenter indent) const {
    273         os << "Attr ";
    274         attr->print( os, indent+1);
    275         if ( isType || expr ) {
    276                 os << "applied to: ";
    277                 if (isType) type->print(os, indent+1);
    278                 else expr->print(os, indent+1);
    279         } // if
    280251        Expression::print( os, indent );
    281252}
  • src/SynTree/Expression.h

    rf673c13 r033ff37  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Feb 18 18:29:51 2019
    13 // Update Count     : 49
     12// Last Modified On : Thu Jul 25 22:21:44 2019
     13// Update Count     : 50
    1414//
    1515
     
    463463};
    464464
    465 /// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
    466 class AttrExpr : public Expression {
    467   public:
    468         Expression * attr;
    469         Expression * expr;
    470         Type * type;
    471         bool isType;
    472 
    473         AttrExpr(Expression * attr, Expression * expr );
    474         AttrExpr( const AttrExpr & other );
    475         AttrExpr( Expression * attr, Type * type );
    476         virtual ~AttrExpr();
    477 
    478         Expression * get_attr() const { return attr; }
    479         void set_attr( Expression * newValue ) { attr = newValue; }
    480         Expression * get_expr() const { return expr; }
    481         void set_expr( Expression * newValue ) { expr = newValue; }
    482         Type * get_type() const { return type; }
    483         void set_type( Type * newValue ) { type = newValue; }
    484         bool get_isType() const { return isType; }
    485         void set_isType( bool newValue ) { isType = newValue; }
    486 
    487         virtual AttrExpr * clone() const override { return new AttrExpr( * this ); }
    488         virtual void accept( Visitor & v ) override { v.visit( this ); }
    489         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    490         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    491         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    492 };
    493 
    494465/// LogicalExpr represents a short-circuit boolean expression (&& or ||)
    495466class LogicalExpr : public Expression {
  • src/SynTree/Mutator.h

    rf673c13 r033ff37  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Jul 24 16:31:00 2017
    13 // Update Count     : 16
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Jul 25 22:37:46 2019
     13// Update Count     : 17
    1414//
    1515#pragma once
     
    7474        virtual Expression * mutate( OffsetofExpr * offsetofExpr ) = 0;
    7575        virtual Expression * mutate( OffsetPackExpr * offsetPackExpr ) = 0;
    76         virtual Expression * mutate( AttrExpr * attrExpr ) = 0;
    7776        virtual Expression * mutate( LogicalExpr * logicalExpr ) = 0;
    7877        virtual Expression * mutate( ConditionalExpr * conditionalExpr ) = 0;
  • src/SynTree/SynTree.h

    rf673c13 r033ff37  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Jul 24 16:54:00 2017
    13 // Update Count     : 11
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Jul 25 22:37:45 2019
     13// Update Count     : 12
    1414//
    1515
     
    7979class OffsetofExpr;
    8080class OffsetPackExpr;
    81 class AttrExpr;
    8281class LogicalExpr;
    8382class ConditionalExpr;
  • src/SynTree/Visitor.h

    rf673c13 r033ff37  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Jul 24 16:28:00 2017
    13 // Update Count     : 13
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Jul 25 22:21:49 2019
     13// Update Count     : 14
    1414//
    1515
     
    123123        virtual void visit( OffsetPackExpr * node ) { visit( const_cast<const OffsetPackExpr *>(node) ); }
    124124        virtual void visit( const OffsetPackExpr * offsetPackExpr ) = 0;
    125         virtual void visit( AttrExpr * node ) { visit( const_cast<const AttrExpr *>(node) ); }
    126         virtual void visit( const AttrExpr * attrExpr ) = 0;
    127125        virtual void visit( LogicalExpr * node ) { visit( const_cast<const LogicalExpr *>(node) ); }
    128126        virtual void visit( const LogicalExpr * logicalExpr ) = 0;
Note: See TracChangeset for help on using the changeset viewer.