- Timestamp:
- Mar 8, 2024, 12:25:49 AM (4 months ago)
- Branches:
- master
- Children:
- 266732e
- Parents:
- 06601401 (diff), 169496e1 (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. - Location:
- src/Parser
- Files:
-
- 7 edited
-
DeclarationNode.cc (modified) (4 diffs)
-
DeclarationNode.h (modified) (4 diffs)
-
ExpressionNode.cc (modified) (2 diffs)
-
TypeData.cc (modified) (3 diffs)
-
TypeData.h (modified) (2 diffs)
-
TypedefTable.cc (modified) (1 diff)
-
parser.yy (modified) (60 diffs)
Legend:
- Unmodified
- Added
- Removed
-
src/Parser/DeclarationNode.cc
r06601401 r03606ce 177 177 } 178 178 179 DeclarationNode * DeclarationNode::newFromTypeData( TypeData * type ) { 180 DeclarationNode * newnode = new DeclarationNode; 181 newnode->type = type; 182 return newnode; 183 } // DeclarationNode::newFromTypeData 184 179 185 DeclarationNode * DeclarationNode::newStorageClass( ast::Storage::Classes sc ) { 180 186 DeclarationNode * newnode = new DeclarationNode; … … 188 194 return newnode; 189 195 } // DeclarationNode::newFuncSpecifier 190 191 DeclarationNode * DeclarationNode::newTypeQualifier( ast::CV::Qualifiers tq ) {192 DeclarationNode * newnode = new DeclarationNode;193 newnode->type = new TypeData();194 newnode->type->qualifiers = tq;195 return newnode;196 } // DeclarationNode::newQualifier197 198 DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {199 DeclarationNode * newnode = new DeclarationNode;200 newnode->type = new TypeData( TypeData::Basic );201 newnode->type->basictype = bt;202 return newnode;203 } // DeclarationNode::newBasicType204 205 DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {206 DeclarationNode * newnode = new DeclarationNode;207 newnode->type = new TypeData( TypeData::Basic );208 newnode->type->complextype = ct;209 return newnode;210 } // DeclarationNode::newComplexType211 212 DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {213 DeclarationNode * newnode = new DeclarationNode;214 newnode->type = new TypeData( TypeData::Basic );215 newnode->type->signedness = sn;216 return newnode;217 } // DeclarationNode::newSignedNess218 219 DeclarationNode * DeclarationNode::newLength( Length lnth ) {220 DeclarationNode * newnode = new DeclarationNode;221 newnode->type = new TypeData( TypeData::Basic );222 newnode->type->length = lnth;223 return newnode;224 } // DeclarationNode::newLength225 226 DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) {227 DeclarationNode * newnode = new DeclarationNode;228 newnode->type = new TypeData( TypeData::Unknown );229 newnode->type->forall = forall;230 return newnode;231 } // DeclarationNode::newForall232 233 DeclarationNode * DeclarationNode::newFromGlobalScope() {234 DeclarationNode * newnode = new DeclarationNode;235 newnode->type = new TypeData( TypeData::GlobalScope );236 return newnode;237 }238 239 DeclarationNode * DeclarationNode::newQualifiedType( DeclarationNode * parent, DeclarationNode * child) {240 DeclarationNode * newnode = new DeclarationNode;241 newnode->type = new TypeData( TypeData::Qualified );242 newnode->type->qualified.parent = parent->type;243 newnode->type->qualified.child = child->type;244 parent->type = nullptr;245 child->type = nullptr;246 delete parent;247 delete child;248 return newnode;249 }250 196 251 197 DeclarationNode * DeclarationNode::newAggregate( ast::AggregateDecl::Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) { … … 312 258 } 313 259 314 DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {315 DeclarationNode * newnode = new DeclarationNode;316 newnode->type = new TypeData( TypeData::SymbolicInst );317 newnode->type->symbolic.name = name;318 newnode->type->symbolic.isTypedef = true;319 newnode->type->symbolic.params = nullptr;320 return newnode;321 } // DeclarationNode::newFromTypedef322 323 DeclarationNode * DeclarationNode::newFromTypeGen( const string * name, ExpressionNode * params ) {324 DeclarationNode * newnode = new DeclarationNode;325 newnode->type = new TypeData( TypeData::SymbolicInst );326 newnode->type->symbolic.name = name;327 newnode->type->symbolic.isTypedef = false;328 newnode->type->symbolic.actuals = params;329 return newnode;330 } // DeclarationNode::newFromTypeGen331 332 260 DeclarationNode * DeclarationNode::newTypeParam( ast::TypeDecl::Kind tc, const string * name ) { 333 261 DeclarationNode * newnode = newName( name ); … … 423 351 return newnode; 424 352 } 425 426 DeclarationNode * DeclarationNode::newVtableType( DeclarationNode * decl ) {427 DeclarationNode * newnode = new DeclarationNode;428 newnode->type = new TypeData( TypeData::Vtable );429 newnode->setBase( decl->type );430 return newnode;431 }432 433 DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) {434 DeclarationNode * newnode = new DeclarationNode;435 newnode->type = new TypeData( TypeData::Builtin );436 newnode->type->builtintype = bt;437 return newnode;438 } // DeclarationNode::newBuiltinType439 353 440 354 DeclarationNode * DeclarationNode::newFunction( const string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) { -
src/Parser/DeclarationNode.h
r06601401 r03606ce 40 40 static const char * builtinTypeNames[]; 41 41 42 static DeclarationNode * newFromTypeData( TypeData * ); 42 43 static DeclarationNode * newStorageClass( ast::Storage::Classes ); 43 44 static DeclarationNode * newFuncSpecifier( ast::Function::Specs ); 44 static DeclarationNode * newTypeQualifier( ast::CV::Qualifiers );45 static DeclarationNode * newBasicType( BasicType );46 static DeclarationNode * newComplexType( ComplexType );47 static DeclarationNode * newSignedNess( Signedness );48 static DeclarationNode * newLength( Length );49 static DeclarationNode * newBuiltinType( BuiltinType );50 static DeclarationNode * newForall( DeclarationNode * );51 static DeclarationNode * newFromTypedef( const std::string * );52 static DeclarationNode * newFromGlobalScope();53 static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );54 45 static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ); 55 46 static DeclarationNode * newAggregate( ast::AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ); … … 59 50 static DeclarationNode * newEnumInLine( const std::string name ); 60 51 static DeclarationNode * newName( const std::string * ); 61 static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );62 52 static DeclarationNode * newTypeParam( ast::TypeDecl::Kind, const std::string * ); 63 53 static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts ); … … 70 60 static DeclarationNode * newTuple( DeclarationNode * members ); 71 61 static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false ); 72 static DeclarationNode * newVtableType( DeclarationNode * expr );73 62 static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes 74 63 static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement … … 163 152 }; // DeclarationNode 164 153 165 ast::Type * buildType( TypeData * type );166 167 154 static inline ast::Type * maybeMoveBuildType( const DeclarationNode * orig ) { 168 155 ast::Type * ret = orig ? orig->buildType() : nullptr; -
src/Parser/ExpressionNode.cc
r06601401 r03606ce 29 29 #include "DeclarationNode.h" // for DeclarationNode 30 30 #include "InitializerNode.h" // for InitializerNode 31 #include "TypeData.h" // for addType, build_basic_type, build_c... 31 32 #include "parserutility.h" // for notZeroExpr 32 33 … … 316 317 v2 ); 317 318 ret = build_compoundLiteral( location, 318 DeclarationNode::new BasicType(319 DeclarationNode::Int128320 )->addType(321 DeclarationNode::newSignedNess( DeclarationNode::Unsigned) ),319 DeclarationNode::newFromTypeData( 320 addType( 321 build_basic_type( DeclarationNode::Int128 ), 322 build_signedness( DeclarationNode::Unsigned ) ) ), 322 323 new InitializerNode( 323 ( InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true )324 (new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true ) 324 325 ); 325 326 } else { // explicit length, (length_type)constant -
src/Parser/TypeData.cc
r06601401 r03606ce 478 478 } 479 479 480 481 480 TypeData * TypeData::getLastBase() { 482 481 TypeData * cur = this; … … 487 486 void TypeData::setLastBase( TypeData * newBase ) { 488 487 getLastBase()->base = newBase; 488 } 489 490 491 TypeData * build_type_qualifier( ast::CV::Qualifiers tq ) { 492 TypeData * type = new TypeData; 493 type->qualifiers = tq; 494 return type; 495 } 496 497 TypeData * build_basic_type( DeclarationNode::BasicType basic ) { 498 TypeData * type = new TypeData( TypeData::Basic ); 499 type->basictype = basic; 500 return type; 501 } 502 503 TypeData * build_complex_type( DeclarationNode::ComplexType complex ) { 504 TypeData * type = new TypeData( TypeData::Basic ); 505 type->complextype = complex; 506 return type; 507 } 508 509 TypeData * build_signedness( DeclarationNode::Signedness signedness ) { 510 TypeData * type = new TypeData( TypeData::Basic ); 511 type->signedness = signedness; 512 return type; 513 } 514 515 TypeData * build_builtin_type( DeclarationNode::BuiltinType bit ) { 516 TypeData * type = new TypeData( TypeData::Builtin ); 517 type->builtintype = bit; 518 return type; 519 } 520 521 TypeData * build_length( DeclarationNode::Length length ) { 522 TypeData * type = new TypeData( TypeData::Basic ); 523 type->length = length; 524 return type; 525 } 526 527 TypeData * build_forall( DeclarationNode * forall ) { 528 TypeData * type = new TypeData( TypeData::Unknown ); 529 type->forall = forall; 530 return type; 531 } 532 533 TypeData * build_global_scope() { 534 return new TypeData( TypeData::GlobalScope ); 535 } 536 537 TypeData * build_qualified_type( TypeData * parent, TypeData * child ) { 538 TypeData * type = new TypeData( TypeData::Qualified ); 539 type->qualified.parent = parent; 540 type->qualified.child = child; 541 return type; 542 } 543 544 TypeData * build_typedef( const std::string * name ) { 545 TypeData * type = new TypeData( TypeData::SymbolicInst ); 546 type->symbolic.name = name; 547 type->symbolic.isTypedef = true; 548 type->symbolic.actuals = nullptr; 549 return type; 550 } 551 552 TypeData * build_type_gen( const std::string * name, ExpressionNode * params ) { 553 TypeData * type = new TypeData( TypeData::SymbolicInst ); 554 type->symbolic.name = name; 555 type->symbolic.isTypedef = false; 556 type->symbolic.actuals = params; 557 return type; 558 } 559 560 TypeData * build_vtable_type( TypeData * base ) { 561 TypeData * type = new TypeData( TypeData::Vtable ); 562 type->base = base; 563 return type; 489 564 } 490 565 … … 627 702 return rtype; 628 703 } // if 704 } 705 706 TypeData * addType( TypeData * ltype, TypeData * rtype ) { 707 std::vector<ast::ptr<ast::Attribute>> attributes; 708 return addType( ltype, rtype, attributes ); 629 709 } 630 710 -
src/Parser/TypeData.h
r06601401 r03606ce 116 116 }; 117 117 118 119 TypeData * build_type_qualifier( ast::CV::Qualifiers ); 120 TypeData * build_basic_type( DeclarationNode::BasicType ); 121 TypeData * build_complex_type( DeclarationNode::ComplexType ); 122 TypeData * build_signedness( DeclarationNode::Signedness ); 123 TypeData * build_builtin_type( DeclarationNode::BuiltinType ); 124 TypeData * build_length( DeclarationNode::Length ); 125 TypeData * build_forall( DeclarationNode * ); 126 TypeData * build_global_scope(); 127 TypeData * build_qualified_type( TypeData *, TypeData * ); 128 TypeData * build_typedef( const std::string * name ); 129 TypeData * build_type_gen( const std::string * name, ExpressionNode * params ); 130 TypeData * build_vtable_type( TypeData * ); 131 118 132 TypeData * addQualifiers( TypeData * ltype, TypeData * rtype ); 119 133 TypeData * addType( TypeData * ltype, TypeData * rtype, std::vector<ast::ptr<ast::Attribute>> & ); 134 TypeData * addType( TypeData * ltype, TypeData * rtype ); 120 135 TypeData * cloneBaseType( TypeData * type, TypeData * other ); 121 136 TypeData * makeNewBase( TypeData * type ); 137 122 138 123 139 ast::Type * typebuild( const TypeData * ); … … 144 160 void buildKRFunction( const TypeData::Function_t & function ); 145 161 162 static inline ast::Type * maybeMoveBuildType( TypeData * type ) { 163 ast::Type * ret = type ? typebuild( type ) : nullptr; 164 delete type; 165 return ret; 166 } 167 146 168 // Local Variables: // 147 169 // tab-width: 4 // -
src/Parser/TypedefTable.cc
r06601401 r03606ce 20 20 #include <string> // for string 21 21 #include <iostream> // for iostream 22 23 struct TypeData; 22 24 23 25 #include "ExpressionNode.h" // for LabelNode -
src/Parser/parser.yy
r06601401 r03606ce 10 10 // Created On : Sat Sep 1 20:22:55 2001 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon Mar 4 08:44:25 202413 // Update Count : 65 6212 // Last Modified On : Wed Mar 6 10:51:55 2024 13 // Update Count : 6588 14 14 // 15 15 … … 317 317 318 318 %union { 319 // A raw token can be used. 319 320 Token tok; 321 322 // The general node types hold some generic node or list of nodes. 323 DeclarationNode * decl; 324 InitializerNode * init; 320 325 ExpressionNode * expr; 321 DeclarationNode * decl;322 ast::AggregateDecl::Aggregate aggKey;323 ast::TypeDecl::Kind tclass;324 326 StatementNode * stmt; 325 327 ClauseNode * clause; 326 ast::WaitForStmt * wfs; 327 ast::WaitUntilStmt::ClauseNode * wucn; 328 TypeData * type; 329 330 // Special "nodes" containing compound information. 328 331 CondCtl * ifctl; 329 332 ForCtrl * forctl; 330 333 LabelNode * labels; 331 InitializerNode * init; 334 335 // Various flags and single values that become fields later. 336 ast::AggregateDecl::Aggregate aggKey; 337 ast::TypeDecl::Kind tclass; 332 338 OperKinds oper; 333 std::string * str;334 339 bool is_volatile; 335 340 EnumHiding enum_hiding; 336 341 ast::ExceptionKind except_kind; 342 // String passes ownership with it. 343 std::string * str; 344 345 // Narrower node types are used to avoid constant unwrapping. 346 ast::WaitForStmt * wfs; 347 ast::WaitUntilStmt::ClauseNode * wucn; 337 348 ast::GenericExpr * genexpr; 338 349 } … … 464 475 465 476 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type 466 %type<decl> vtable vtable_opt default_opt 477 %type<type> basic_type_name_type 478 %type<type> vtable vtable_opt default_opt 467 479 468 480 %type<decl> trait_declaration trait_declaration_list trait_declaring_list trait_specifier … … 519 531 %type<decl> type_declarator type_declarator_name type_declaring_list 520 532 521 %type<decl> type_declaration_specifier type_type_specifier type_name typegen_name 533 %type<decl> type_declaration_specifier type_type_specifier 534 %type<type> type_name typegen_name 522 535 %type<decl> typedef_name typedef_declaration typedef_expression 523 536 … … 532 545 %type<expr> type_parameters_opt type_list array_type_list // array_dimension_list 533 546 534 %type<decl> type_qualifier type_qualifier_name forall type_qualifier_list_opt type_qualifier_list 547 %type<decl> type_qualifier forall type_qualifier_list_opt type_qualifier_list 548 %type<type> type_qualifier_name 535 549 %type<decl> type_specifier type_specifier_nobody 536 550 … … 687 701 { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); } 688 702 | TYPEDIMname // CFA, generic length argument 689 // { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( DeclarationNode::newFromTypedef( $1 ) ) ) ); }690 // { $$ = new ExpressionNode( build_varref( $1 ) ); }691 703 { $$ = new ExpressionNode( build_dimensionref( yylloc, $1 ) ); } 692 704 | tuple … … 696 708 { $$ = new ExpressionNode( new ast::StmtExpr( yylloc, dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( $2 ) ) ) ); } 697 709 | type_name '.' identifier // CFA, nested type 698 { $$ = new ExpressionNode( build_qualified_expr( yylloc, $1, build_varref( yylloc, $3 ) ) ); }710 { $$ = new ExpressionNode( build_qualified_expr( yylloc, DeclarationNode::newFromTypeData( $1 ), build_varref( yylloc, $3 ) ) ); } 699 711 | type_name '.' '[' field_name_list ']' // CFA, nested type / tuple field selector 700 712 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; } … … 751 763 // Switching to this behaviour may help check if a C compatibilty case uses comma-exprs in subscripts. 752 764 // Current: Commas in subscripts make tuples. 753 { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }765 { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, new ExpressionNode( build_tuple( yylloc, $3->set_last( $5 ) ) ) ) ); } 754 766 | postfix_expression '[' assignment_expression ']' 755 767 // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a … … 766 778 Token fn; 767 779 fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? 768 $$ = new ExpressionNode( new ast::ConstructorExpr( yylloc, build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );780 $$ = new ExpressionNode( new ast::ConstructorExpr( yylloc, build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), $1->set_last( $3 ) ) ) ); 769 781 } 770 782 | postfix_expression '(' argument_expression_list_opt ')' … … 772 784 | VA_ARG '(' primary_expression ',' declaration_specifier_nobody abstract_parameter_declarator_opt ')' 773 785 // { SemanticError( yylloc, "va_arg is currently unimplemented." ); $$ = nullptr; } 774 { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, new string( "__builtin_va_arg" ) ) ),775 (ExpressionNode *)($3->set_last( (ExpressionNode *)($6 ? $6->addType( $5 ) : $5) )) ) ); }786 { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, new string( "__builtin_va_arg" ) ) ), 787 $3->set_last( (ExpressionNode *)($6 ? $6->addType( $5 ) : $5) ) ) ); } 776 788 | postfix_expression '`' identifier // CFA, postfix call 777 789 { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); } … … 831 843 Token fn; 832 844 fn.str = new string( "^?{}" ); // location undefined 833 $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );845 $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), $2->set_last( $4 ) ) ); 834 846 } 835 847 ; … … 844 856 argument_expression 845 857 | argument_expression_list_opt ',' argument_expression 846 { $$ = (ExpressionNode *)($1->set_last( $3 )); }858 { $$ = $1->set_last( $3 ); } 847 859 ; 848 860 … … 856 868 field_name_list: // CFA, tuple field selector 857 869 field 858 | field_name_list ',' field { $$ = (ExpressionNode *)($1->set_last( $3 )); }870 | field_name_list ',' field { $$ = $1->set_last( $3 ); } 859 871 ; 860 872 … … 938 950 | ALIGNOF '(' type_no_function ')' // GCC, type alignment 939 951 { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); } 952 953 // Cannot use rule "type", which includes cfa_abstract_function, for sizeof/alignof, because of S/R problems on 954 // look ahead, so the cfa_abstract_function is factored out. 955 | SIZEOF '(' cfa_abstract_function ')' 956 { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); } 957 | ALIGNOF '(' cfa_abstract_function ')' // GCC, type alignment 958 { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); } 959 940 960 | OFFSETOF '(' type_no_function ',' identifier ')' 941 961 { $$ = new ExpressionNode( build_offsetOf( yylloc, $3, build_varref( yylloc, $5 ) ) ); } 942 | TYPEID '(' type _no_function')'962 | TYPEID '(' type ')' 943 963 { 944 964 SemanticError( yylloc, "typeid name is currently unimplemented." ); $$ = nullptr; … … 970 990 { $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); } 971 991 | '(' VIRTUAL ')' cast_expression // CFA 972 { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $4 ), maybeMoveBuildType( nullptr )) ); }992 { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $4 ), nullptr ) ); } 973 993 | '(' VIRTUAL type_no_function ')' cast_expression // CFA 974 994 { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); } … … 1142 1162 // { $$ = new ExpressionNode( build_tuple( $3 ) ); } 1143 1163 '[' ',' tuple_expression_list ']' 1144 { $$ = new ExpressionNode( build_tuple( yylloc, ( ExpressionNode *)(new ExpressionNode( nullptr ))->set_last( $3 ) ) ); }1164 { $$ = new ExpressionNode( build_tuple( yylloc, (new ExpressionNode( nullptr ))->set_last( $3 ) ) ); } 1145 1165 | '[' push assignment_expression pop ',' tuple_expression_list ']' 1146 { $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $6 ) ) )); }1166 { $$ = new ExpressionNode( build_tuple( yylloc, $3->set_last( $6 ) ) ); } 1147 1167 ; 1148 1168 … … 1152 1172 { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; } 1153 1173 | tuple_expression_list ',' assignment_expression 1154 { $$ = (ExpressionNode *)($1->set_last( $3 )); }1174 { $$ = $1->set_last( $3 ); } 1155 1175 | tuple_expression_list ',' '@' 1156 1176 { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; } … … 1238 1258 { assert( $1 ); $1->set_last( $2 ); $$ = $1; } 1239 1259 | statement_list_nodecl error // invalid syntax rule 1240 { SemanticError( yylloc, "syntax error, declarations only allowed at the start of the switch body, i.e., after the '{'." ); $$ = nullptr; } 1260 { SemanticError( yylloc, "syntax error, declarations only allowed at the start of the switch body," 1261 " i.e., after the '{'." ); $$ = nullptr; } 1241 1262 ; 1242 1263 … … 1246 1267 ; 1247 1268 1248 // if, switch, and choose require parenthesis around the conditional because it can be followed by a statement. 1249 // For example, without parenthesis: 1250 // 1251 // if x + y + z; => "if ( x + y ) + z" or "if ( x ) + y + z" 1252 // switch ( S ) { ... } => switch ( S ) { compound literal... } ... or 1269 // "if", "switch", and "choose" require parenthesis around the conditional. See the following ambiguities without 1270 // parenthesis: 1271 // 1272 // if x + y + z; => "if ( x + y ) + z" or "if ( x ) + y + z" 1273 // 1274 // switch O { } 1275 // 1276 // O{} => object-constructor for conditional, switch body ??? 1277 // O{} => O for conditional followed by switch body 1278 // 1279 // C++ has this problem, as it has the same constructor syntax. 1280 // 1281 // switch sizeof ( T ) { } 1282 // 1283 // sizeof ( T ) => sizeof of T for conditional followed by switch body 1284 // sizeof ( T ) => sizeof of compound literal (T){ }, closing parenthesis ??? 1285 // 1286 // Note the two grammar rules for sizeof (alignof) 1287 // 1288 // | SIZEOF unary_expression 1289 // | SIZEOF '(' type_no_function ')' 1290 // 1291 // where the first DOES NOT require parenthesis! And C++ inherits this problem from C. 1253 1292 1254 1293 selection_statement: … … 1268 1307 // therefore, are removed from the grammar even though C allows it. The change also applies to choose 1269 1308 // statement. 1270 $$ = $7 ? new StatementNode( build_compound( yylloc, ( StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;1309 $$ = $7 ? new StatementNode( build_compound( yylloc, (new StatementNode( $7 ))->set_last( sw ) ) ) : sw; 1271 1310 } 1272 1311 | SWITCH '(' comma_expression ')' '{' error '}' // CFA, invalid syntax rule error … … 1277 1316 { 1278 1317 StatementNode *sw = new StatementNode( build_switch( yylloc, false, $3, $8 ) ); 1279 $$ = $7 ? new StatementNode( build_compound( yylloc, ( StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;1318 $$ = $7 ? new StatementNode( build_compound( yylloc, (new StatementNode( $7 ))->set_last( sw ) ) ) : sw; 1280 1319 } 1281 1320 | CHOOSE '(' comma_expression ')' '{' error '}' // CFA, invalid syntax rule … … 1679 1718 cast_expression 1680 1719 | cast_expression_list ',' cast_expression 1681 // { $$ = (ExpressionNode *)($1->set_last( $3 )); }1682 1720 { SemanticError( yylloc, "List of mutex member is currently unimplemented." ); $$ = nullptr; } 1683 1721 ; … … 1695 1733 { $$ = $3; } 1696 1734 | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')' 1697 { $$ = (ExpressionNode *)($3->set_last( $5 )); }1735 { $$ = $3->set_last( $5 ); } 1698 1736 ; 1699 1737 … … 1851 1889 asm_operand 1852 1890 | asm_operands_list ',' asm_operand 1853 { $$ = (ExpressionNode *)($1->set_last( $3 )); }1891 { $$ = $1->set_last( $3 ); } 1854 1892 ; 1855 1893 … … 1870 1908 { $$ = $1; } 1871 1909 | asm_clobbers_list_opt ',' string_literal 1872 { $$ = (ExpressionNode *)( $1->set_last( $3 )); }1910 { $$ = $1->set_last( $3 ); } 1873 1911 ; 1874 1912 … … 2188 2226 type_qualifier: 2189 2227 type_qualifier_name 2228 { $$ = DeclarationNode::newFromTypeData( $1 ); } 2190 2229 | attribute // trick handles most attribute locations 2191 2230 ; … … 2193 2232 type_qualifier_name: 2194 2233 CONST 2195 { $$ = DeclarationNode::newTypeQualifier( ast::CV::Const ); }2234 { $$ = build_type_qualifier( ast::CV::Const ); } 2196 2235 | RESTRICT 2197 { $$ = DeclarationNode::newTypeQualifier( ast::CV::Restrict ); }2236 { $$ = build_type_qualifier( ast::CV::Restrict ); } 2198 2237 | VOLATILE 2199 { $$ = DeclarationNode::newTypeQualifier( ast::CV::Volatile ); }2238 { $$ = build_type_qualifier( ast::CV::Volatile ); } 2200 2239 | ATOMIC 2201 { $$ = DeclarationNode::newTypeQualifier( ast::CV::Atomic ); } 2240 { $$ = build_type_qualifier( ast::CV::Atomic ); } 2241 2242 // forall must be a CV qualifier because it can appear in places where SC qualifiers are disallowed. 2243 // 2244 // void foo( forall( T ) T (*)( T ) ); // forward declaration 2245 // void bar( static int ); // static disallowed (gcc/CFA) 2202 2246 | forall 2203 { $$ = DeclarationNode::newForall( $1 ); }2247 { $$ = build_forall( $1 ); } 2204 2248 ; 2205 2249 … … 2251 2295 2252 2296 basic_type_name: 2297 basic_type_name_type 2298 { $$ = DeclarationNode::newFromTypeData( $1 ); } 2299 ; 2300 2301 // Just an intermediate value for conversion. 2302 basic_type_name_type: 2253 2303 VOID 2254 { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }2304 { $$ = build_basic_type( DeclarationNode::Void ); } 2255 2305 | BOOL // C99 2256 { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }2306 { $$ = build_basic_type( DeclarationNode::Bool ); } 2257 2307 | CHAR 2258 { $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); }2308 { $$ = build_basic_type( DeclarationNode::Char ); } 2259 2309 | INT 2260 { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }2310 { $$ = build_basic_type( DeclarationNode::Int ); } 2261 2311 | INT128 2262 { $$ = DeclarationNode::newBasicType( DeclarationNode::Int128 ); }2312 { $$ = build_basic_type( DeclarationNode::Int128 ); } 2263 2313 | UINT128 2264 { $$ = DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ); }2314 { $$ = addType( build_basic_type( DeclarationNode::Int128 ), build_signedness( DeclarationNode::Unsigned ) ); } 2265 2315 | FLOAT 2266 { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }2316 { $$ = build_basic_type( DeclarationNode::Float ); } 2267 2317 | DOUBLE 2268 { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }2318 { $$ = build_basic_type( DeclarationNode::Double ); } 2269 2319 | uuFLOAT80 2270 { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat80 ); }2320 { $$ = build_basic_type( DeclarationNode::uuFloat80 ); } 2271 2321 | uuFLOAT128 2272 { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat128 ); }2322 { $$ = build_basic_type( DeclarationNode::uuFloat128 ); } 2273 2323 | uFLOAT16 2274 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat16 ); }2324 { $$ = build_basic_type( DeclarationNode::uFloat16 ); } 2275 2325 | uFLOAT32 2276 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32 ); }2326 { $$ = build_basic_type( DeclarationNode::uFloat32 ); } 2277 2327 | uFLOAT32X 2278 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32x ); }2328 { $$ = build_basic_type( DeclarationNode::uFloat32x ); } 2279 2329 | uFLOAT64 2280 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64 ); }2330 { $$ = build_basic_type( DeclarationNode::uFloat64 ); } 2281 2331 | uFLOAT64X 2282 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64x ); }2332 { $$ = build_basic_type( DeclarationNode::uFloat64x ); } 2283 2333 | uFLOAT128 2284 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat128 ); }2334 { $$ = build_basic_type( DeclarationNode::uFloat128 ); } 2285 2335 | DECIMAL32 2286 2336 { SemanticError( yylloc, "_Decimal32 is currently unimplemented." ); $$ = nullptr; } … … 2290 2340 { SemanticError( yylloc, "_Decimal128 is currently unimplemented." ); $$ = nullptr; } 2291 2341 | COMPLEX // C99 2292 { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }2342 { $$ = build_complex_type( DeclarationNode::Complex ); } 2293 2343 | IMAGINARY // C99 2294 { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }2344 { $$ = build_complex_type( DeclarationNode::Imaginary ); } 2295 2345 | SIGNED 2296 { $$ = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }2346 { $$ = build_signedness( DeclarationNode::Signed ); } 2297 2347 | UNSIGNED 2298 { $$ = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }2348 { $$ = build_signedness( DeclarationNode::Unsigned ); } 2299 2349 | SHORT 2300 { $$ = DeclarationNode::newLength( DeclarationNode::Short ); }2350 { $$ = build_length( DeclarationNode::Short ); } 2301 2351 | LONG 2302 { $$ = DeclarationNode::newLength( DeclarationNode::Long ); }2352 { $$ = build_length( DeclarationNode::Long ); } 2303 2353 | VA_LIST // GCC, __builtin_va_list 2304 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }2354 { $$ = build_builtin_type( DeclarationNode::Valist ); } 2305 2355 | AUTO_TYPE 2306 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::AutoType ); }2356 { $$ = build_builtin_type( DeclarationNode::AutoType ); } 2307 2357 | vtable 2308 2358 ; … … 2316 2366 vtable: 2317 2367 VTABLE '(' type_name ')' default_opt 2318 { $$ = DeclarationNode::newVtableType( $3 ); } 2319 // { SemanticError( yylloc, "vtable is currently unimplemented." ); $$ = nullptr; } 2368 { $$ = build_vtable_type( $3 ); } 2320 2369 ; 2321 2370 … … 2367 2416 { $$ = DeclarationNode::newTypeof( $3, true ); } 2368 2417 | ZERO_T // CFA 2369 { $$ = DeclarationNode::new BuiltinType( DeclarationNode::Zero); }2418 { $$ = DeclarationNode::newFromTypeData( build_builtin_type( DeclarationNode::Zero ) ); } 2370 2419 | ONE_T // CFA 2371 { $$ = DeclarationNode::new BuiltinType( DeclarationNode::One); }2420 { $$ = DeclarationNode::newFromTypeData( build_builtin_type( DeclarationNode::One ) ); } 2372 2421 ; 2373 2422 … … 2425 2474 type_type_specifier: // typedef types 2426 2475 type_name 2476 { $$ = DeclarationNode::newFromTypeData( $1 ); } 2427 2477 | type_qualifier_list type_name 2428 { $$ = $2->addQualifiers( $1 ); }2478 { $$ = DeclarationNode::newFromTypeData( $2 )->addQualifiers( $1 ); } 2429 2479 | type_type_specifier type_qualifier 2430 2480 { $$ = $1->addQualifiers( $2 ); } … … 2433 2483 type_name: 2434 2484 TYPEDEFname 2435 { $$ = DeclarationNode::newFromTypedef( $1 ); }2485 { $$ = build_typedef( $1 ); } 2436 2486 | '.' TYPEDEFname 2437 { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), DeclarationNode::newFromTypedef( $2 ) ); }2487 { $$ = build_qualified_type( build_global_scope(), build_typedef( $2 ) ); } 2438 2488 | type_name '.' TYPEDEFname 2439 { $$ = DeclarationNode::newQualifiedType( $1, DeclarationNode::newFromTypedef( $3 ) ); }2489 { $$ = build_qualified_type( $1, build_typedef( $3 ) ); } 2440 2490 | typegen_name 2441 2491 | '.' typegen_name 2442 { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), $2 ); }2492 { $$ = build_qualified_type( build_global_scope(), $2 ); } 2443 2493 | type_name '.' typegen_name 2444 { $$ = DeclarationNode::newQualifiedType( $1, $3 ); }2494 { $$ = build_qualified_type( $1, $3 ); } 2445 2495 ; 2446 2496 2447 2497 typegen_name: // CFA 2448 2498 TYPEGENname 2449 { $$ = DeclarationNode::newFromTypeGen( $1, nullptr ); }2499 { $$ = build_type_gen( $1, nullptr ); } 2450 2500 | TYPEGENname '(' ')' 2451 { $$ = DeclarationNode::newFromTypeGen( $1, nullptr ); }2501 { $$ = build_type_gen( $1, nullptr ); } 2452 2502 | TYPEGENname '(' type_list ')' 2453 { $$ = DeclarationNode::newFromTypeGen( $1, $3 ); }2503 { $$ = build_type_gen( $1, $3 ); } 2454 2504 ; 2455 2505 … … 2463 2513 | enum_type_nobody 2464 2514 ; 2515 2516 // ************************** AGGREGATE ******************************* 2465 2517 2466 2518 aggregate_type: // struct, union … … 2485 2537 '{' field_declaration_list_opt '}' type_parameters_opt 2486 2538 { 2487 DeclarationNode::newFromType def( $3);2539 DeclarationNode::newFromTypeData( build_typedef( $3 ) ); 2488 2540 $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 ); 2489 2541 } … … 2495 2547 '{' field_declaration_list_opt '}' type_parameters_opt 2496 2548 { 2497 DeclarationNode::newFromType Gen( $3, nullptr);2549 DeclarationNode::newFromTypeData( build_type_gen( $3, nullptr ) ); 2498 2550 $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 ); 2499 2551 } … … 2520 2572 // Create new generic declaration with same name as previous forward declaration, where the IDENTIFIER is 2521 2573 // switched to a TYPEGENname. Link any generic arguments from typegen_name to new generic declaration and 2522 // delete newFromTypeGen. 2523 if ( $3->type->kind == TypeData::SymbolicInst && ! $3->type->symbolic.isTypedef ) { 2524 $$ = $3->addQualifiers( $2 ); 2574 if ( $3->kind == TypeData::SymbolicInst && ! $3->symbolic.isTypedef ) { 2575 $$ = DeclarationNode::newFromTypeData( $3 )->addQualifiers( $2 ); 2525 2576 } else { 2526 $$ = DeclarationNode::newAggregate( $1, $3-> type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 );2527 $3-> type->symbolic.name = nullptr; // copied to $$2528 $3-> type->symbolic.actuals = nullptr;2577 $$ = DeclarationNode::newAggregate( $1, $3->symbolic.name, $3->symbolic.actuals, nullptr, false )->addQualifiers( $2 ); 2578 $3->symbolic.name = nullptr; // copied to $$ 2579 $3->symbolic.actuals = nullptr; 2529 2580 delete $3; 2530 2581 } … … 2544 2595 | EXCEPTION // CFA 2545 2596 { $$ = ast::AggregateDecl::Exception; } 2546 // { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = ast::AggregateDecl::NoAggregate; }2547 2597 ; 2548 2598 … … 2683 2733 ; 2684 2734 2685 // *********** 2686 // Enumeration 2687 // *********** 2735 // ************************** ENUMERATION ******************************* 2688 2736 2689 2737 enum_type: … … 2754 2802 | ENUM attribute_list_opt type_name 2755 2803 { 2756 typedefTable.makeTypedef( *$3-> type->symbolic.name, "enum_type_nobody 2" );2757 $$ = DeclarationNode::newEnum( $3-> type->symbolic.name, nullptr, false, false )->addQualifiers( $2 );2804 typedefTable.makeTypedef( *$3->symbolic.name, "enum_type_nobody 2" ); 2805 $$ = DeclarationNode::newEnum( $3->symbolic.name, nullptr, false, false )->addQualifiers( $2 ); 2758 2806 } 2759 2807 ; … … 2763 2811 { $$ = DeclarationNode::newEnumValueGeneric( $2, $3 ); } 2764 2812 | INLINE type_name 2765 { $$ = DeclarationNode::newEnumInLine( *$2-> type->symbolic.name ); }2813 { $$ = DeclarationNode::newEnumInLine( *$2->symbolic.name ); } 2766 2814 | enumerator_list ',' visible_hide_opt identifier_or_type_name enumerator_value_opt 2767 2815 { $$ = $1->set_last( DeclarationNode::newEnumValueGeneric( $4, $5 ) ); } … … 2785 2833 ; 2786 2834 2787 // ******************* 2788 // Function parameters 2789 // ******************* 2835 // ************************** FUNCTION PARAMETERS ******************************* 2790 2836 2791 2837 parameter_list_ellipsis_opt: … … 2810 2856 cfa_parameter_list_ellipsis_opt: // CFA, abstract + real 2811 2857 // empty 2812 { $$ = DeclarationNode::new BasicType( DeclarationNode::Void); }2858 { $$ = DeclarationNode::newFromTypeData( build_basic_type( DeclarationNode::Void ) ); } 2813 2859 | ELLIPSIS 2814 2860 { $$ = nullptr; } … … 2868 2914 | type_qualifier_list cfa_abstract_tuple identifier_or_type_name default_initializer_opt 2869 2915 { $$ = $2->addName( $3 )->addQualifiers( $1 ); } 2870 | cfa_function_specifier 2916 | cfa_function_specifier // int f( "int fp()" ); 2871 2917 ; 2872 2918 … … 2878 2924 | type_qualifier_list cfa_abstract_tuple 2879 2925 { $$ = $2->addQualifiers( $1 ); } 2880 | cfa_abstract_function 2926 | cfa_abstract_function // int f( "int ()" ); 2881 2927 ; 2882 2928 … … 2928 2974 | initializer 2929 2975 | designation initializer { $$ = $2->set_designators( $1 ); } 2930 | initializer_list_opt ',' initializer { $$ = (InitializerNode *)( $1->set_last( $3 )); }2931 | initializer_list_opt ',' designation initializer { $$ = (InitializerNode *)($1->set_last( $4->set_designators( $3 ) )); }2976 | initializer_list_opt ',' initializer { $$ = $1->set_last( $3 ); } 2977 | initializer_list_opt ',' designation initializer { $$ = $1->set_last( $4->set_designators( $3 ) ); } 2932 2978 ; 2933 2979 … … 2951 2997 designator 2952 2998 | designator_list designator 2953 { $$ = (ExpressionNode *)($1->set_last( $2 )); }2999 { $$ = $1->set_last( $2 ); } 2954 3000 //| designator_list designator { $$ = new ExpressionNode( $1, $2 ); } 2955 3001 ; … … 3036 3082 { $$ = ast::TypeDecl::Dtype; } 3037 3083 | '*' 3038 { $$ = ast::TypeDecl::DStype; } // dtype + sized3039 // | '(' '*' ')' 3040 // { $$ = ast::TypeDecl::Ftype; }3084 { $$ = ast::TypeDecl::DStype; } // Dtype + sized 3085 // | '(' '*' ')' // Gregor made me do it 3086 // { $$ = ast::TypeDecl::Ftype; } 3041 3087 | ELLIPSIS 3042 3088 { $$ = ast::TypeDecl::Ttype; } … … 3080 3126 | assignment_expression 3081 3127 | type_list ',' type 3082 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }3128 { $$ = $1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) ); } 3083 3129 | type_list ',' assignment_expression 3084 { $$ = (ExpressionNode *)( $1->set_last( $3 )); }3130 { $$ = $1->set_last( $3 ); } 3085 3131 ; 3086 3132 … … 3244 3290 $$ = $6; 3245 3291 } 3246 // global distribution3292 // global distribution 3247 3293 | type_qualifier_list 3248 3294 { … … 3369 3415 ; 3370 3416 3417 // **************************** ASM ***************************** 3418 3371 3419 asm_name_opt: // GCC 3372 3420 // empty … … 3379 3427 } 3380 3428 ; 3429 3430 // **************************** ATTRIBUTE ***************************** 3381 3431 3382 3432 attribute_list_opt: // GCC … … 3742 3792 { $$ = $1->addQualifiers( $2 ); } 3743 3793 | '&' MUTEX paren_identifier attribute_list_opt 3744 { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::new TypeQualifier( ast::CV::Mutex),3794 { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newFromTypeData( build_type_qualifier( ast::CV::Mutex ) ), 3745 3795 OperKinds::AddressOf ) )->addQualifiers( $4 ); } 3746 3796 | identifier_parameter_ptr … … 3793 3843 { $$ = $1->addQualifiers( $2 ); } 3794 3844 | '&' MUTEX typedef_name attribute_list_opt 3795 { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::new TypeQualifier( ast::CV::Mutex),3845 { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newFromTypeData( build_type_qualifier( ast::CV::Mutex ) ), 3796 3846 OperKinds::AddressOf ) )->addQualifiers( $4 ); } 3797 3847 | type_parameter_ptr … … 3826 3876 3827 3877 type_parameter_function: 3828 typedef_name '(' parameter_list_ellipsis_opt ')' 3878 typedef_name '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3) 3829 3879 { $$ = $1->addParamList( $3 ); } 3830 3880 | '(' type_parameter_ptr ')' '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3) … … 3876 3926 3877 3927 abstract_function: 3878 '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3)3928 '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3) 3879 3929 { $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); } 3880 3930 | '(' abstract_ptr ')' '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3) … … 3915 3965 | assignment_expression upupeq assignment_expression 3916 3966 | array_type_list ',' basic_type_name 3917 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }3967 { $$ = $1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) ); } 3918 3968 | array_type_list ',' type_name 3919 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }3969 { $$ = $1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) ); } 3920 3970 | array_type_list ',' assignment_expression upupeq assignment_expression 3921 3971 ; … … 3977 4027 abstract_parameter_ptr 3978 4028 | '&' MUTEX attribute_list_opt 3979 { $$ = DeclarationNode::newPointer( DeclarationNode::new TypeQualifier( ast::CV::Mutex), OperKinds::AddressOf )->addQualifiers( $3 ); }4029 { $$ = DeclarationNode::newPointer( DeclarationNode::newFromTypeData( build_type_qualifier( ast::CV::Mutex ) ), OperKinds::AddressOf )->addQualifiers( $3 ); } 3980 4030 | abstract_parameter_array attribute_list_opt 3981 4031 { $$ = $1->addQualifiers( $2 ); } … … 4008 4058 4009 4059 abstract_parameter_function: 4010 '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3)4060 '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3) 4011 4061 { $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); } 4012 4062 | '(' abstract_parameter_ptr ')' '(' parameter_list_ellipsis_opt ')' // empty parameter list OBSOLESCENT (see 3) … … 4280 4330 // mode: c++ // 4281 4331 // tab-width: 4 // 4282 // compile-command: " make install" //4332 // compile-command: "bison -Wcounterexamples parser.yy" // 4283 4333 // End: //
Note: See TracChangeset
for help on using the changeset viewer.
