Changeset 7f6a7c9 for src/Parser
- Timestamp:
- Sep 21, 2022, 11:02:15 AM (3 years ago)
- Branches:
- ADT, ast-experimental, master, pthread-emulation
- Children:
- 95dab9e
- Parents:
- 428adbc (diff), 0bd46fd (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:
-
- 8 edited
-
DeclarationNode.cc (modified) (11 diffs)
-
ExpressionNode.cc (modified) (1 diff)
-
ParseNode.h (modified) (2 diffs)
-
TypeData.cc (modified) (6 diffs)
-
TypeData.h (modified) (3 diffs)
-
TypedefTable.cc (modified) (5 diffs)
-
lex.ll (modified) (4 diffs)
-
parser.yy (modified) (15 diffs)
Legend:
- Unmodified
- Added
- Removed
-
src/Parser/DeclarationNode.cc
r428adbc r7f6a7c9 10 10 // Created On : Sat May 16 12:34:05 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Jul 14 17:36:57 202113 // Update Count : 11 5412 // Last Modified On : Mon Aug 8 17:07:00 2022 13 // Update Count : 1185 14 14 // 15 15 … … 128 128 if ( name ) { 129 129 os << *name << ": "; 130 } else {131 os << "unnamed: ";132 130 } // if 133 131 … … 154 152 initializer->printOneLine( os ); 155 153 os << " maybe constructed? " << initializer->get_maybeConstructed(); 156 157 } // if 154 } // if 155 156 for ( Attribute * attr: reverseIterate( attributes ) ) { 157 os << string( indent + 2, ' ' ) << "attr " << attr->name.c_str(); 158 } // for 158 159 159 160 os << endl; … … 243 244 newnode->type = new TypeData( TypeData::Aggregate ); 244 245 newnode->type->aggregate.kind = kind; 245 newnode->type->aggregate.name = 246 newnode->type->aggregate.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name; 246 247 newnode->type->aggregate.actuals = actuals; 247 248 newnode->type->aggregate.fields = fields; … … 253 254 } // DeclarationNode::newAggregate 254 255 255 DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, DeclarationNode * base) {256 DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base) { 256 257 DeclarationNode * newnode = new DeclarationNode; 257 258 newnode->type = new TypeData( TypeData::Enum ); … … 260 261 newnode->type->enumeration.body = body; 261 262 newnode->type->enumeration.anon = name == nullptr; 263 newnode->type->enumeration.typed = typed; 262 264 if ( base && base->type) { 263 newnode->type->base = base->type; 264 } // if 265 266 // Check: if base has TypeData 265 newnode->type->base = base->type; 266 } // if 267 267 268 return newnode; 268 269 } // DeclarationNode::newEnum … … 284 285 285 286 DeclarationNode * DeclarationNode::newEnumValueGeneric( const string * name, InitializerNode * init ) { 286 if ( init ) { // list init {} or a singleInit287 if ( init->get_expression() ) { // singleInit287 if ( init ) { 288 if ( init->get_expression() ) { 288 289 return newEnumConstant( name, init->get_expression() ); 289 } else { // TODO: listInit290 } else { 290 291 DeclarationNode * newnode = newName( name ); 291 292 newnode->initializer = init; … … 293 294 } // if 294 295 } else { 295 return newName( name ); // Not explicitly inited enum value;296 return newName( name ); 296 297 } // if 297 298 } // DeclarationNode::newEnumValueGeneric … … 504 505 } // for 505 506 // src is the new item being added and has a single bit 506 } else if ( ! src->storageClasses.is_threadlocal ) { // conflict ?507 } else if ( ! src->storageClasses.is_threadlocal_any() ) { // conflict ? 507 508 appendError( error, string( "conflicting " ) + Type::StorageClassesNames[storageClasses.ffs()] + 508 509 " & " + Type::StorageClassesNames[src->storageClasses.ffs()] ); … … 518 519 storageClasses |= q->storageClasses; 519 520 520 for ( Attribute * attr: reverseIterate( q->attributes ) ) {521 for ( Attribute * attr: reverseIterate( q->attributes ) ) { 521 522 attributes.push_front( attr->clone() ); 522 523 } // for … … 683 684 } // if 684 685 delete o; 686 685 687 return this; 686 688 } -
src/Parser/ExpressionNode.cc
r428adbc r7f6a7c9 509 509 } // build_varref 510 510 511 QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name ) { 512 Declaration * newDecl = maybeBuild< Declaration >(decl_node); 513 if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { 514 const Type * t = newDeclWithType->get_type(); 515 if ( t ) { 516 if ( const TypeInstType * typeInst = dynamic_cast<const TypeInstType *>( t ) ) { 517 newDecl= new EnumDecl( typeInst->name ); 518 } 519 } 520 } 521 auto ret = new QualifiedNameExpr( newDecl, name->name ); 522 if ( auto e = dynamic_cast<EnumDecl*>(newDecl) ) { 523 auto enumInst = new EnumInstType( Type::Qualifiers(), e ); 524 auto obj = new ObjectDecl( name->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, enumInst, nullptr ); 525 ret->set_var( obj ); 526 } 527 return ret; 528 } 529 530 QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl_node, const NameExpr * name ) { 531 EnumDecl * newDecl = const_cast< EnumDecl * >( decl_node ); 532 return new QualifiedNameExpr( newDecl, name->name ); 533 } 534 511 535 DimensionExpr * build_dimensionref( const string * name ) { 512 536 DimensionExpr * expr = new DimensionExpr( *name ); -
src/Parser/ParseNode.h
r428adbc r7f6a7c9 183 183 184 184 NameExpr * build_varref( const std::string * name ); 185 QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name ); 186 QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl, const NameExpr * name ); 185 187 DimensionExpr * build_dimensionref( const std::string * name ); 186 188 … … 235 237 static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ); 236 238 static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ); 237 static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, DeclarationNode * base = nullptr );239 static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr ); 238 240 static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant ); 239 241 static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init ); -
src/Parser/TypeData.cc
r428adbc r7f6a7c9 9 9 // Author : Rodolfo G. Esteves 10 10 // Created On : Sat May 16 15:12:51 2015 11 // Last Modified By : Henry Xue12 // Last Modified On : Tue Jul 20 04:10:50 202113 // Update Count : 67 311 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue May 10 22:36:52 2022 13 // Update Count : 677 14 14 // 15 15 … … 283 283 if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " "; 284 284 if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " "; 285 if ( complextype == DeclarationNode::NoComplexType ) { // basic type 286 assert( basictype != DeclarationNode::NoBasicType ); 287 os << DeclarationNode::basicTypeNames[ basictype ] << " "; 288 } else { // complex type 289 // handle double _Complex 290 if ( basictype != DeclarationNode::NoBasicType ) os << DeclarationNode::basicTypeNames[ basictype ] << " "; 291 os << DeclarationNode::complexTypeNames[ complextype ] << " "; 292 } // if 285 if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeNames[ complextype ] << " "; 286 if ( basictype != DeclarationNode::NoBasicType ) os << DeclarationNode::basicTypeNames[ basictype ] << " "; 293 287 break; 294 288 case Pointer: … … 437 431 __attribute__((fallthrough)); 438 432 #endif 433 // FALL THROUGH 439 434 case Typeof: 440 435 os << "type-of expression "; … … 442 437 typeexpr->print( os, indent + 2 ); 443 438 } // if 439 break; 440 case Vtable: 441 os << "vtable"; 444 442 break; 445 443 case Builtin: … … 548 546 return buildAggInst( td ); 549 547 case TypeData::EnumConstant: 550 // the name gets filled in later -- by SymTab::Validate551 548 return new EnumInstType( buildQualifiers( td ), "" ); 552 549 case TypeData::SymbolicInst: … … 923 920 assert( td->kind == TypeData::Enum ); 924 921 Type * baseType = td->base ? typebuild(td->base) : nullptr; 925 EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage, baseType );922 EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, td->enumeration.typed, linkage, baseType ); 926 923 buildList( td->enumeration.constants, ret->get_members() ); 927 924 list< Declaration * >::iterator members = ret->get_members().begin(); 928 925 for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) { 929 if ( cur->has_enumeratorValue() ) { 926 if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) { 927 SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." ); 928 } else if ( cur->has_enumeratorValue() ) { 930 929 ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members); 931 930 member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) ); 932 931 } else if ( !cur->initializer ) { 933 932 if ( baseType && (!dynamic_cast<BasicType *>(baseType) || !dynamic_cast<BasicType *>(baseType)->isWholeNumber())) { 934 SemanticError( td->location, " A non whole number enum value declmust be explicitly initialized." );933 SemanticError( td->location, "Enumerators of an non-integer typed enum must be explicitly initialized." ); 935 934 } 936 935 } -
src/Parser/TypeData.h
r428adbc r7f6a7c9 10 10 // Created On : Sat May 16 15:18:36 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Jul 14 17:44:05 202113 // Update Count : 20 212 // Last Modified On : Tue May 10 22:18:49 2022 13 // Update Count : 203 14 14 // 15 15 … … 27 27 struct TypeData { 28 28 enum Kind { Basic, Pointer, Reference, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic, 29 SymbolicInst, Tuple, Typeof, Basetypeof, Vtable, Builtin, GlobalScope, Qualified, Unknown };29 SymbolicInst, Tuple, Basetypeof, Typeof, Vtable, Builtin, GlobalScope, Qualified, Unknown }; 30 30 31 31 struct Aggregate_t { … … 59 59 bool body; 60 60 bool anon; 61 bool typed; 61 62 }; 62 63 -
src/Parser/TypedefTable.cc
r428adbc r7f6a7c9 10 10 // Created On : Sat May 16 15:20:13 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed May 19 08:30:14 202113 // Update Count : 2 6212 // Last Modified On : Tue Feb 15 08:27:24 2022 13 // Update Count : 275 14 14 // 15 15 … … 18 18 #include <cassert> // for assert 19 19 #include <iostream> 20 using namespace std; 20 21 21 22 #if 0 … … 28 29 29 30 debugPrint( 30 static const char *kindName( int kind ) {31 switch ( kind ) {32 case IDENTIFIER: return "identifier";33 case TYPEDIMname: return "typedim";34 case TYPEDEFname: return "typedef";35 case TYPEGENname: return "typegen";36 default:37 cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl;38 abort();39 } // switch40 } // kindName41 ) 31 static const char *kindName( int kind ) { 32 switch ( kind ) { 33 case IDENTIFIER: return "identifier"; 34 case TYPEDIMname: return "typedim"; 35 case TYPEDEFname: return "typedef"; 36 case TYPEGENname: return "typegen"; 37 default: 38 cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl; 39 abort(); 40 } // switch 41 } // kindName 42 ); 42 43 43 44 TypedefTable::~TypedefTable() { … … 80 81 81 82 void TypedefTable::addToScope( const string & identifier, int kind, const char * locn __attribute__((unused)) ) { 82 autoscope = kindTable.currentScope();83 KindTable::size_type scope = kindTable.currentScope(); 83 84 debugPrint( cerr << "Adding current at " << locn << " " << identifier << " as " << kindName( kind ) << " scope " << scope << endl ); 84 85 kindTable.insertAt( scope, identifier, kind ); … … 86 87 87 88 void TypedefTable::addToEnclosingScope( const string & identifier, int kind, const char * locn __attribute__((unused)) ) { 88 autoscope = kindTable.currentScope() - 1 - kindTable.getNote( kindTable.currentScope() - 1 ).level;89 // autoscope = level - kindTable.getNote( kindTable.currentScope() - 1 ).level;89 KindTable::size_type scope = kindTable.currentScope() - 1 - kindTable.getNote( kindTable.currentScope() - 1 ).level; 90 // size_type scope = level - kindTable.getNote( kindTable.currentScope() - 1 ).level; 90 91 debugPrint( cerr << "Adding enclosing at " << locn << " " << identifier << " as " << kindName( kind ) << " scope " << scope << " level " << level << " note " << kindTable.getNote( kindTable.currentScope() - 1 ).level << endl ); 91 autoret = kindTable.insertAt( scope, identifier, kind );92 pair< KindTable::iterator, bool > ret = kindTable.insertAt( scope, identifier, kind ); 92 93 if ( ! ret.second ) ret.first->second = kind; // exists => update 93 94 } // TypedefTable::addToEnclosingScope -
src/Parser/lex.ll
r428adbc r7f6a7c9 10 10 * Created On : Sat Sep 22 08:58:10 2001 11 11 * Last Modified By : Peter A. Buhr 12 * Last Modified On : Sun Jun 20 18:41:09 202113 * Update Count : 7 5912 * Last Modified On : Tue Sep 20 21:18:55 2022 13 * Update Count : 762 14 14 */ 15 15 … … 24 24 25 25 //**************************** Includes and Defines **************************** 26 27 #ifdef __clang__ 28 #pragma GCC diagnostic ignored "-Wnull-conversion" 29 #endif 26 30 27 31 // trigger before each matching rule's action … … 82 86 // Stop warning due to incorrectly generated flex code. 83 87 #pragma GCC diagnostic ignored "-Wsign-compare" 84 85 // lex uses __null in a boolean context, it's fine.86 #pragma GCC diagnostic ignored "-Wnull-conversion"87 88 %} 88 89 … … 314 315 switch { KEYWORD_RETURN(SWITCH); } 315 316 thread { KEYWORD_RETURN(THREAD); } // C11 316 _Thread_local { KEYWORD_RETURN(THREADLOCAL); } // C11 317 __thread { KEYWORD_RETURN(THREADLOCALGCC); } // GCC 318 _Thread_local { KEYWORD_RETURN(THREADLOCALC11); } // C11 317 319 throw { KEYWORD_RETURN(THROW); } // CFA 318 320 throwResume { KEYWORD_RETURN(THROWRESUME); } // CFA -
src/Parser/parser.yy
r428adbc r7f6a7c9 10 10 // Created On : Sat Sep 1 20:22:55 2001 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Jul 1 15:35:08 202213 // Update Count : 5 40512 // Last Modified On : Sat Aug 27 13:21:28 2022 13 // Update Count : 5661 14 14 // 15 15 … … 58 58 59 59 // lex uses __null in a boolean context, it's fine. 60 #ifdef __clang__ 60 61 #pragma GCC diagnostic ignored "-Wparentheses-equality" 62 #endif 61 63 62 64 extern DeclarationNode * parseTree; … … 197 199 } // fieldDecl 198 200 201 #define NEW_ZERO new ExpressionNode( build_constantInteger( *new string( "0" ) ) ) 202 #define NEW_ONE new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) 203 #define UPDOWN( compop, left, right ) (compop == OperKinds::LThan || compop == OperKinds::LEThan ? left : right) 204 #define MISSING_ANON_FIELD "Missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body." 205 #define MISSING_LOW "Missing low value for up-to range so index is uninitialized." 206 #define MISSING_HIGH "Missing high value for down-to range so index is uninitialized." 207 208 ForCtrl * forCtrl( DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) { 209 if ( index->initializer ) { 210 SemanticError( yylloc, "Direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." ); 211 } // if 212 if ( index->next ) { 213 SemanticError( yylloc, "Multiple loop indexes disallowed in for-loop declaration." ); 214 } // if 215 return new ForCtrl( index->addInitializer( new InitializerNode( start ) ), 216 // NULL comp/inc => leave blank 217 comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index->name ) ) ), comp ) ) : nullptr, 218 inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto 219 OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index->name ) ) ), inc ) ) : nullptr ); 220 } // forCtrl 221 199 222 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) { 200 223 ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->expr.get()); … … 206 229 distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ), 207 230 // NULL comp/inc => leave blank 208 comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ) : 0,231 comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ) : nullptr, 209 232 inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto 210 OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) : 0);233 OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) : nullptr ); 211 234 } // forCtrl 212 235 … … 272 295 %token TYPEDEF 273 296 %token EXTERN STATIC AUTO REGISTER 274 %token THREADLOCAL //C11297 %token THREADLOCALGCC THREADLOCALC11 // GCC, C11 275 298 %token INLINE FORTRAN // C99, extension ISO/IEC 9899:1999 Section J.5.9(1) 276 299 %token NORETURN // C11 … … 346 369 %type<ifctl> conditional_declaration 347 370 %type<fctl> for_control_expression for_control_expression_list 348 %type<compop> inclexcl371 %type<compop> updown updowneq downupdowneq 349 372 %type<en> subrange 350 373 %type<decl> asm_name_opt … … 614 637 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild<Statement>($2) ) ) ); } 615 638 | type_name '.' identifier // CFA, nested type 616 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }639 { $$ = new ExpressionNode( build_qualified_expr( $1, build_varref( $3 ) ) ); } 617 640 | type_name '.' '[' field_name_list ']' // CFA, nested type / tuple field selector 618 641 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; } … … 1239 1262 iteration_statement: 1240 1263 WHILE '(' ')' statement %prec THEN // CFA => while ( 1 ) 1241 { $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) )), maybe_build_compound( $4 ) ) ); }1264 { $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) ); } 1242 1265 | WHILE '(' ')' statement ELSE statement // CFA 1243 1266 { 1244 $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) )), maybe_build_compound( $4 ) ) );1267 $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) ); 1245 1268 SemanticWarning( yylloc, Warning::SuperfluousElse, "" ); 1246 1269 } … … 1250 1273 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ), $7 ) ); } 1251 1274 | DO statement WHILE '(' ')' ';' // CFA => do while( 1 ) 1252 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }1275 { $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) ); } 1253 1276 | DO statement WHILE '(' ')' ELSE statement // CFA 1254 1277 { 1255 $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) );1278 $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) ); 1256 1279 SemanticWarning( yylloc, Warning::SuperfluousElse, "" ); 1257 1280 } … … 1304 1327 { $$ = new ForCtrl( $1, $2, $4 ); } 1305 1328 1306 | comma_expression // CFA 1307 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), 1308 OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); } 1309 | '=' comma_expression // CFA 1310 { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), 1311 OperKinds::LEThan, $2->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); } 1312 | comma_expression inclexcl comma_expression // CFA 1313 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); } 1314 | comma_expression inclexcl comma_expression '~' comma_expression // CFA 1315 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); } 1316 | comma_expression ';' // CFA 1317 { $$ = forCtrl( new ExpressionNode( build_constantInteger( *new string( "0u" ) ) ), $1, nullptr, OperKinds::LThan, nullptr, nullptr ); } 1329 | '@' ';' comma_expression // CFA, empty loop-index 1330 { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, nullptr ); } 1331 | '@' ';' comma_expression ';' comma_expression // CFA, empty loop-index 1332 { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, $5 ); } 1333 1334 | comma_expression // CFA, anonymous loop-index 1335 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), NEW_ZERO, OperKinds::LThan, $1->clone(), NEW_ONE ); } 1336 | downupdowneq comma_expression // CFA, anonymous loop-index 1337 { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $1, NEW_ZERO, $2->clone() ), $1, UPDOWN( $1, $2->clone(), NEW_ZERO ), NEW_ONE ); } 1338 1339 | comma_expression updowneq comma_expression // CFA, anonymous loop-index 1340 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), NEW_ONE ); } 1341 | '@' updowneq comma_expression // CFA, anonymous loop-index 1342 { 1343 if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; } 1344 else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, NEW_ONE ); 1345 } 1346 | comma_expression updowneq '@' // CFA, anonymous loop-index 1347 { 1348 if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } 1349 else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 1350 } 1351 | comma_expression updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index 1352 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), $5 ); } 1353 | '@' updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index 1354 { 1355 if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; } 1356 else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, $5 ); 1357 } 1358 | comma_expression updowneq '@' '~' comma_expression // CFA, anonymous loop-index 1359 { 1360 if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } 1361 else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 1362 } 1363 | comma_expression updowneq comma_expression '~' '@' // CFA, error 1364 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } 1365 | '@' updowneq '@' // CFA, error 1366 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } 1367 | '@' updowneq comma_expression '~' '@' // CFA, error 1368 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } 1369 | comma_expression updowneq '@' '~' '@' // CFA, error 1370 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } 1371 | '@' updowneq '@' '~' '@' // CFA, error 1372 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } 1373 1318 1374 | comma_expression ';' comma_expression // CFA 1319 { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), 1320 OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); } 1321 | comma_expression ';' '=' comma_expression // CFA 1322 { $$ = forCtrl( $4, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), 1323 OperKinds::LEThan, $4->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); } 1324 | comma_expression ';' comma_expression inclexcl comma_expression // CFA 1325 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); } 1326 | comma_expression ';' comma_expression inclexcl comma_expression '~' comma_expression // CFA 1327 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); } 1375 { $$ = forCtrl( $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); } 1376 | comma_expression ';' downupdowneq comma_expression // CFA 1377 { $$ = forCtrl( $4, $1, UPDOWN( $3, NEW_ZERO, $4->clone() ), $3, UPDOWN( $3, $4->clone(), NEW_ZERO ), NEW_ONE ); } 1378 1379 | comma_expression ';' comma_expression updowneq comma_expression // CFA 1380 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), NEW_ONE ); } 1381 | comma_expression ';' '@' updowneq comma_expression // CFA 1382 { 1383 if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; } 1384 else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, NEW_ONE ); 1385 } 1386 | comma_expression ';' comma_expression updowneq '@' // CFA 1387 { 1388 if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 1389 else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } 1390 else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, NEW_ONE ); 1391 } 1392 | comma_expression ';' '@' updowneq '@' // CFA, error 1393 { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; } 1394 1395 | comma_expression ';' comma_expression updowneq comma_expression '~' comma_expression // CFA 1396 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); } 1397 | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, error 1398 { 1399 if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; } 1400 else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, $7 ); 1401 } 1402 | comma_expression ';' comma_expression updowneq '@' '~' comma_expression // CFA 1403 { 1404 if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 1405 else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } 1406 else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, $7 ); 1407 } 1408 | comma_expression ';' comma_expression updowneq comma_expression '~' '@' // CFA 1409 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); } 1410 | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, error 1411 { 1412 if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; } 1413 else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, nullptr ); 1414 } 1415 | comma_expression ';' comma_expression updowneq '@' '~' '@' // CFA 1416 { 1417 if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 1418 else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } 1419 else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, nullptr ); 1420 } 1421 | comma_expression ';' '@' updowneq '@' '~' '@' // CFA 1422 { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; } 1423 1424 | declaration comma_expression // CFA 1425 { $$ = forCtrl( $1, NEW_ZERO, OperKinds::LThan, $2, NEW_ONE ); } 1426 | declaration downupdowneq comma_expression // CFA 1427 { $$ = forCtrl( $1, UPDOWN( $2, NEW_ZERO, $3 ), $2, UPDOWN( $2, $3->clone(), NEW_ZERO ), NEW_ONE ); } 1428 1429 | declaration comma_expression updowneq comma_expression // CFA 1430 { $$ = forCtrl( $1, UPDOWN( $3, $2->clone(), $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), NEW_ONE ); } 1431 | declaration '@' updowneq comma_expression // CFA 1432 { 1433 if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; } 1434 else $$ = forCtrl( $1, $4, $3, nullptr, NEW_ONE ); 1435 } 1436 | declaration comma_expression updowneq '@' // CFA 1437 { 1438 if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 1439 else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } 1440 else $$ = forCtrl( $1, $2, $3, nullptr, NEW_ONE ); 1441 } 1442 1443 | declaration comma_expression updowneq comma_expression '~' comma_expression // CFA 1444 { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), $6 ); } 1445 | declaration '@' updowneq comma_expression '~' comma_expression // CFA 1446 { 1447 if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; } 1448 else $$ = forCtrl( $1, $4, $3, nullptr, $6 ); 1449 } 1450 | declaration comma_expression updowneq '@' '~' comma_expression // CFA 1451 { 1452 if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 1453 else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } 1454 else $$ = forCtrl( $1, $2, $3, nullptr, $6 ); 1455 } 1456 | declaration comma_expression updowneq comma_expression '~' '@' // CFA 1457 { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), nullptr ); } 1458 | declaration '@' updowneq comma_expression '~' '@' // CFA 1459 { 1460 if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; } 1461 else $$ = forCtrl( $1, $4, $3, nullptr, nullptr ); 1462 } 1463 | declaration comma_expression updowneq '@' '~' '@' // CFA 1464 { 1465 if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 1466 else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } 1467 else $$ = forCtrl( $1, $2, $3, nullptr, nullptr ); 1468 } 1469 | declaration '@' updowneq '@' '~' '@' // CFA, error 1470 { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; } 1328 1471 1329 1472 | comma_expression ';' TYPEDEFname // CFA, array type 1330 1473 { 1331 SemanticError( yylloc, "Array interator is currently unimplemented." ); $$ = nullptr; 1332 $$ = forCtrl( new ExpressionNode( build_varref( $3 ) ), $1, nullptr, OperKinds::Range, nullptr, nullptr ); 1333 } 1334 1335 // There is a S/R conflicit if ~ and -~ are factored out. 1336 | comma_expression ';' comma_expression '~' '@' // CFA 1337 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); } 1338 | comma_expression ';' comma_expression ErangeDown '@' // CFA 1339 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::GThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); } 1340 | comma_expression ';' comma_expression '~' '@' '~' comma_expression // CFA 1341 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, $7 ); } 1342 | comma_expression ';' comma_expression ErangeDown '@' '~' comma_expression // CFA 1343 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::GThan, nullptr, $7 ); } 1344 | comma_expression ';' comma_expression '~' '@' '~' '@' // CFA 1345 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, nullptr ); } 1474 SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr; 1475 //$$ = forCtrl( new ExpressionNode( build_varref( $3 ) ), $1, nullptr, OperKinds::Range, nullptr, nullptr ); 1476 } 1477 | comma_expression ';' downupdowneq TYPEDEFname // CFA, array type 1478 { 1479 if ( $3 == OperKinds::LEThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, "All enumation ranges are equal (all values). Remove \"=~\"." ); $$ = nullptr; } 1480 SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr; 1481 } 1346 1482 ; 1347 1483 1348 inclexcl: 1484 downupdowneq: 1485 ErangeDown 1486 { $$ = OperKinds::GThan; } 1487 | ErangeUpEq 1488 { $$ = OperKinds::LEThan; } 1489 | ErangeDownEq 1490 { $$ = OperKinds::GEThan; } 1491 ; 1492 1493 updown: 1349 1494 '~' 1350 1495 { $$ = OperKinds::LThan; } 1496 | ErangeDown 1497 { $$ = OperKinds::GThan; } 1498 ; 1499 1500 updowneq: 1501 updown 1351 1502 | ErangeUpEq 1352 1503 { $$ = OperKinds::LEThan; } 1353 | ErangeDown1354 { $$ = OperKinds::GThan; }1355 1504 | ErangeDownEq 1356 1505 { $$ = OperKinds::GEThan; } … … 1935 2084 | REGISTER 1936 2085 { $$ = DeclarationNode::newStorageClass( Type::Register ); } 1937 | THREADLOCAL // C11 1938 { $$ = DeclarationNode::newStorageClass( Type::Threadlocal ); } 2086 | THREADLOCALGCC // GCC 2087 { $$ = DeclarationNode::newStorageClass( Type::ThreadlocalGcc ); } 2088 | THREADLOCALC11 // C11 2089 { $$ = DeclarationNode::newStorageClass( Type::ThreadlocalC11 ); } 1939 2090 // Put function specifiers here to simplify parsing rules, but separate them semantically. 1940 2091 | INLINE // C99 … … 2387 2538 enum_type: 2388 2539 ENUM attribute_list_opt '{' enumerator_list comma_opt '}' 2389 { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }2540 { $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); } 2390 2541 | ENUM attribute_list_opt identifier 2391 2542 { typedefTable.makeTypedef( *$3 ); } 2392 2543 '{' enumerator_list comma_opt '}' 2393 { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }2544 { $$ = DeclarationNode::newEnum( $3, $6, true, false )->addQualifiers( $2 ); } 2394 2545 | ENUM attribute_list_opt typedef_name // unqualified type name 2395 2546 '{' enumerator_list comma_opt '}' 2396 { $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }2547 { $$ = DeclarationNode::newEnum( $3->name, $5, true, false )->addQualifiers( $2 ); } 2397 2548 | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}' 2398 2549 { … … 2400 2551 { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); } 2401 2552 2402 $$ = DeclarationNode::newEnum( nullptr, $7, true, $3 )->addQualifiers( $5 ); 2553 $$ = DeclarationNode::newEnum( nullptr, $7, true, true, $3 )->addQualifiers( $5 ); 2554 } 2555 | ENUM '(' ')' attribute_list_opt '{' enumerator_list comma_opt '}' 2556 { 2557 $$ = DeclarationNode::newEnum( nullptr, $6, true, true )->addQualifiers( $4 ); 2403 2558 } 2404 2559 | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt … … 2409 2564 '{' enumerator_list comma_opt '}' 2410 2565 { 2411 $$ = DeclarationNode::newEnum( $6, $10, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 ); 2566 $$ = DeclarationNode::newEnum( $6, $10, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 ); 2567 } 2568 | ENUM '(' ')' attribute_list_opt identifier attribute_list_opt 2569 '{' enumerator_list comma_opt '}' 2570 { 2571 $$ = DeclarationNode::newEnum( $5, $8, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 ); 2412 2572 } 2413 2573 | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}' 2414 2574 { 2415 if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); } 2416 typedefTable.makeTypedef( *$6->name ); 2417 $$ = DeclarationNode::newEnum( $6->name, $9, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 ); 2575 $$ = DeclarationNode::newEnum( $6->name, $9, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 ); 2576 } 2577 | ENUM '(' ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}' 2578 { 2579 $$ = DeclarationNode::newEnum( $5->name, $8, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 ); 2418 2580 } 2419 2581 | enum_type_nobody … … 2422 2584 enum_type_nobody: // enum - {...} 2423 2585 ENUM attribute_list_opt identifier 2424 { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 ); }2425 | ENUM attribute_list_opt type_name // qualified type name2426 { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 ); }2586 { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); } 2587 | ENUM attribute_list_opt type_name 2588 { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); } 2427 2589 ; 2428 2590
Note:
See TracChangeset
for help on using the changeset viewer.
