Changeset c8ffe20b for translator/Parser/TypeData.cc
- Timestamp:
- Nov 15, 2014, 10:46:42 PM (9 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc
- Children:
- 1ead581
- Parents:
- 8c17ab0
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
translator/Parser/TypeData.cc
r8c17ab0 rc8ffe20b 10 10 11 11 12 TypeData::TypeData( Kind k ) 13 : kind( k ), base( 0 ), forall( 0 ) 14 { 15 switch( kind ) { 16 case Unknown: 17 case Pointer: 18 case EnumConstant: 19 // nothing else to initialize 20 break; 21 22 case Basic: 23 basic = new Basic_t; 24 break; 25 26 case Array: 27 array = new Array_t; 28 array->dimension = 0; 29 array->isVarLen = false; 30 array->isStatic = false; 31 break; 32 33 case Function: 34 function = new Function_t; 35 function->params = 0; 36 function->idList = 0; 37 function->oldDeclList = 0; 38 function->body = 0; 39 function->hasBody = false; 40 break; 41 42 case Aggregate: 43 aggregate = new Aggregate_t; 44 aggregate->params = 0; 45 aggregate->actuals = 0; 46 aggregate->members = 0; 47 break; 48 49 case AggregateInst: 50 aggInst = new AggInst_t; 51 aggInst->aggregate = 0; 52 aggInst->params = 0; 53 break; 54 55 case Enum: 56 enumeration = new Enumeration_t; 57 enumeration->constants = 0; 58 break; 59 60 case Symbolic: 61 case SymbolicInst: 62 symbolic = new Symbolic_t; 63 symbolic->params = 0; 64 symbolic->actuals = 0; 65 symbolic->assertions = 0; 66 break; 67 68 case Variable: 69 variable = new Variable_t; 70 variable->tyClass = DeclarationNode::Type; 71 variable->assertions = 0; 72 break; 73 74 case Tuple: 75 tuple = new Tuple_t; 76 tuple->members = 0; 77 break; 12 TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) { 13 switch ( kind ) { 14 case Unknown: 15 case Pointer: 16 case EnumConstant: 17 // nothing else to initialize 18 break; 19 case Basic: 20 basic = new Basic_t; 21 break; 22 case Array: 23 array = new Array_t; 24 array->dimension = 0; 25 array->isVarLen = false; 26 array->isStatic = false; 27 break; 28 case Function: 29 function = new Function_t; 30 function->params = 0; 31 function->idList = 0; 32 function->oldDeclList = 0; 33 function->body = 0; 34 function->hasBody = false; 35 break; 36 case Aggregate: 37 aggregate = new Aggregate_t; 38 aggregate->params = 0; 39 aggregate->actuals = 0; 40 aggregate->members = 0; 41 break; 42 case AggregateInst: 43 aggInst = new AggInst_t; 44 aggInst->aggregate = 0; 45 aggInst->params = 0; 46 break; 47 case Enum: 48 enumeration = new Enumeration_t; 49 enumeration->constants = 0; 50 break; 51 case Symbolic: 52 case SymbolicInst: 53 symbolic = new Symbolic_t; 54 symbolic->params = 0; 55 symbolic->actuals = 0; 56 symbolic->assertions = 0; 57 break; 58 case Variable: 59 variable = new Variable_t; 60 variable->tyClass = DeclarationNode::Type; 61 variable->assertions = 0; 62 break; 63 case Tuple: 64 tuple = new Tuple_t; 65 tuple->members = 0; 66 break; 78 67 79 case Typeof:80 81 82 68 case Typeof: 69 typeexpr = new Typeof_t; 70 typeexpr->expr = 0; 71 break; 83 72 84 case Attr: 85 attr = new Attr_t; 86 attr->expr = 0; 87 attr->type = 0; 88 break; 89 } 90 } 91 92 TypeData::~TypeData() 93 { 94 delete base; 95 delete forall; 96 97 switch( kind ) { 98 case Unknown: 99 case Pointer: 100 case EnumConstant: 101 // nothing to destroy 102 break; 103 104 case Basic: 105 delete basic; 106 break; 107 108 case Array: 109 delete array->dimension; 110 delete array; 111 break; 112 113 case Function: 114 delete function->params; 115 delete function->idList; 116 delete function->oldDeclList; 117 delete function->body; 118 delete function; 119 break; 120 121 case Aggregate: 122 delete aggregate->params; 123 delete aggregate->actuals; 124 delete aggregate->members; 125 delete aggregate; 126 break; 127 128 case AggregateInst: 129 delete aggInst->aggregate; 130 delete aggInst->params; 131 delete aggInst; 132 break; 133 134 case Enum: 135 delete enumeration->constants; 136 delete enumeration; 137 break; 138 139 case Symbolic: 140 case SymbolicInst: 141 delete symbolic->params; 142 delete symbolic->actuals; 143 delete symbolic->assertions; 144 delete symbolic; 145 break; 146 147 case Variable: 148 delete variable->assertions; 149 delete variable; 150 break; 151 152 case Tuple: 153 delete tuple->members; 154 delete tuple; 155 break; 73 case Attr: 74 attr = new Attr_t; 75 attr->expr = 0; 76 attr->type = 0; 77 break; 78 } 79 } 80 81 TypeData::~TypeData() { 82 delete base; 83 delete forall; 84 85 switch ( kind ) { 86 case Unknown: 87 case Pointer: 88 case EnumConstant: 89 // nothing to destroy 90 break; 91 case Basic: 92 delete basic; 93 break; 94 case Array: 95 delete array->dimension; 96 delete array; 97 break; 98 case Function: 99 delete function->params; 100 delete function->idList; 101 delete function->oldDeclList; 102 delete function->body; 103 delete function; 104 break; 105 case Aggregate: 106 delete aggregate->params; 107 delete aggregate->actuals; 108 delete aggregate->members; 109 delete aggregate; 110 break; 111 case AggregateInst: 112 delete aggInst->aggregate; 113 delete aggInst->params; 114 delete aggInst; 115 break; 116 case Enum: 117 delete enumeration->constants; 118 delete enumeration; 119 break; 120 case Symbolic: 121 case SymbolicInst: 122 delete symbolic->params; 123 delete symbolic->actuals; 124 delete symbolic->assertions; 125 delete symbolic; 126 break; 127 case Variable: 128 delete variable->assertions; 129 delete variable; 130 break; 131 case Tuple: 132 delete tuple->members; 133 delete tuple; 134 break; 156 135 157 case Typeof:158 159 160 136 case Typeof: 137 delete typeexpr->expr; 138 delete typeexpr; 139 break; 161 140 162 case Attr: 163 delete attr->expr; 164 delete attr->type; 165 delete attr; 166 break; 167 } 168 } 169 170 TypeData * 171 TypeData::clone() const 172 { 173 TypeData *newtype = new TypeData( kind ); 174 newtype->qualifiers = qualifiers; 175 newtype->base = maybeClone( base ); 176 newtype->forall = maybeClone( forall ); 177 178 switch( kind ) { 179 case Unknown: 180 case EnumConstant: 181 case Pointer: 182 // nothing else to copy 183 break; 184 185 case Basic: 186 newtype->basic->typeSpec = basic->typeSpec; 187 newtype->basic->modifiers = basic->modifiers; 188 break; 189 190 case Array: 191 newtype->array->dimension = maybeClone( array->dimension ); 192 newtype->array->isVarLen = array->isVarLen; 193 newtype->array->isStatic = array->isStatic; 194 break; 195 196 case Function: 197 newtype->function->params = maybeClone( function->params ); 198 newtype->function->idList = maybeClone( function->idList ); 199 newtype->function->oldDeclList = maybeClone( function->oldDeclList ); 200 newtype->function->body = maybeClone( function->body ); 201 newtype->function->hasBody = function->hasBody; 202 newtype->function->newStyle = function->newStyle; 203 break; 204 205 case Aggregate: 206 newtype->aggregate->params = maybeClone( aggregate->params ); 207 newtype->aggregate->actuals = maybeClone( aggregate->actuals ); 208 newtype->aggregate->members = maybeClone( aggregate->members ); 209 newtype->aggregate->name = aggregate->name; 210 newtype->aggregate->kind = aggregate->kind; 211 break; 212 213 case AggregateInst: 214 newtype->aggInst->aggregate = maybeClone( aggInst->aggregate ); 215 newtype->aggInst->params = maybeClone( aggInst->params ); 216 break; 217 218 case Enum: 219 newtype->enumeration->name = enumeration->name; 220 newtype->enumeration->constants = maybeClone( enumeration->constants ); 221 break; 222 223 case Symbolic: 224 case SymbolicInst: 225 newtype->symbolic->params = maybeClone( symbolic->params ); 226 newtype->symbolic->actuals = maybeClone( symbolic->actuals ); 227 newtype->symbolic->assertions = maybeClone( symbolic->assertions ); 228 newtype->symbolic->isTypedef = symbolic->isTypedef; 229 newtype->symbolic->name = symbolic->name; 230 break; 231 232 case Variable: 233 newtype->variable->assertions = maybeClone( variable->assertions ); 234 newtype->variable->name = variable->name; 235 newtype->variable->tyClass = variable->tyClass; 236 break; 237 238 case Tuple: 239 newtype->tuple->members = maybeClone( tuple->members ); 240 break; 141 case Attr: 142 delete attr->expr; 143 delete attr->type; 144 delete attr; 145 break; 146 } 147 } 148 149 TypeData *TypeData::clone() const { 150 TypeData *newtype = new TypeData( kind ); 151 newtype->qualifiers = qualifiers; 152 newtype->base = maybeClone( base ); 153 newtype->forall = maybeClone( forall ); 154 155 switch ( kind ) { 156 case Unknown: 157 case EnumConstant: 158 case Pointer: 159 // nothing else to copy 160 break; 161 case Basic: 162 newtype->basic->typeSpec = basic->typeSpec; 163 newtype->basic->modifiers = basic->modifiers; 164 break; 165 case Array: 166 newtype->array->dimension = maybeClone( array->dimension ); 167 newtype->array->isVarLen = array->isVarLen; 168 newtype->array->isStatic = array->isStatic; 169 break; 170 case Function: 171 newtype->function->params = maybeClone( function->params ); 172 newtype->function->idList = maybeClone( function->idList ); 173 newtype->function->oldDeclList = maybeClone( function->oldDeclList ); 174 newtype->function->body = maybeClone( function->body ); 175 newtype->function->hasBody = function->hasBody; 176 newtype->function->newStyle = function->newStyle; 177 break; 178 case Aggregate: 179 newtype->aggregate->params = maybeClone( aggregate->params ); 180 newtype->aggregate->actuals = maybeClone( aggregate->actuals ); 181 newtype->aggregate->members = maybeClone( aggregate->members ); 182 newtype->aggregate->name = aggregate->name; 183 newtype->aggregate->kind = aggregate->kind; 184 break; 185 case AggregateInst: 186 newtype->aggInst->aggregate = maybeClone( aggInst->aggregate ); 187 newtype->aggInst->params = maybeClone( aggInst->params ); 188 break; 189 case Enum: 190 newtype->enumeration->name = enumeration->name; 191 newtype->enumeration->constants = maybeClone( enumeration->constants ); 192 break; 193 case Symbolic: 194 case SymbolicInst: 195 newtype->symbolic->params = maybeClone( symbolic->params ); 196 newtype->symbolic->actuals = maybeClone( symbolic->actuals ); 197 newtype->symbolic->assertions = maybeClone( symbolic->assertions ); 198 newtype->symbolic->isTypedef = symbolic->isTypedef; 199 newtype->symbolic->name = symbolic->name; 200 break; 201 case Variable: 202 newtype->variable->assertions = maybeClone( variable->assertions ); 203 newtype->variable->name = variable->name; 204 newtype->variable->tyClass = variable->tyClass; 205 break; 206 case Tuple: 207 newtype->tuple->members = maybeClone( tuple->members ); 208 break; 241 209 242 case Typeof:243 244 210 case Typeof: 211 newtype->typeexpr->expr = maybeClone( typeexpr->expr ); 212 break; 245 213 246 case Attr: 247 newtype->attr->expr = maybeClone( attr->expr ); 248 newtype->attr->type = maybeClone( attr->type ); 249 break; 250 } 251 return newtype; 252 } 253 254 void 255 TypeData::print( std::ostream &os, int indent ) const 256 { 257 using std::endl; 258 using std::string; 259 260 printEnums( qualifiers.begin(), qualifiers.end(), DeclarationNode::qualifierName, os ); 261 262 if( forall ) { 263 os << "forall " << endl; 264 forall->printList( os, indent+4 ); 265 } 266 267 switch( kind ) { 268 case Unknown: 269 os << "entity of unknown type "; 270 break; 271 272 case Pointer: 273 os << "pointer "; 274 if( base ) { 275 os << "to "; 276 base->print( os, indent ); 277 } 278 break; 279 280 case EnumConstant: 281 os << "enumeration constant "; 282 break; 283 284 case Basic: 285 printEnums( basic->modifiers.begin(), basic->modifiers.end(), DeclarationNode::modifierName, os ); 286 printEnums( basic->typeSpec.begin(), basic->typeSpec.end(), DeclarationNode::basicTypeName, os ); 287 break; 288 289 case Array: 290 if( array->isStatic ) { 291 os << "static "; 292 } 293 if( array->dimension ) { 294 os << "array of "; 295 array->dimension->printOneLine( os, indent ); 296 } else if ( array->isVarLen ) { 297 os << "variable-length array of "; 298 } else { 299 os << "open array of "; 300 } 301 if( base ) { 302 base->print( os, indent ); 303 } 304 break; 305 306 case Function: 307 os << "function" << endl; 308 if ( function->params ) { 309 os << string( indent+2, ' ' ) << "with parameters " << endl; 310 function->params->printList( os, indent+4 ); 311 } else { 312 os << string( indent+2, ' ' ) << "with no parameters " << endl; 313 } 314 if ( function->idList ) { 315 os << string( indent+2, ' ' ) << "with old-style identifier list " << endl; 316 function->idList->printList( os, indent+4 ); 317 } 318 if ( function->oldDeclList ) { 319 os << string( indent+2, ' ' ) << "with old-style declaration list " << endl; 320 function->oldDeclList->printList( os, indent+4 ); 321 } 322 os << string( indent+2, ' ' ) << "returning "; 323 if ( base ) { 324 base->print( os, indent+4 ); 325 } else { 326 os << "nothing "; 327 } 328 os << endl; 329 if ( function->hasBody ) { 330 os << string( indent+2, ' ' ) << "with body " << endl; 331 } 332 if ( function->body ) { 333 function->body->printList( os, indent+2 ); 334 } 335 break; 336 337 case Aggregate: 338 os << DeclarationNode::tyConName[ aggregate->kind ] << ' ' << aggregate->name << endl; 339 if( aggregate->params ) { 340 os << string( indent+2, ' ' ) << "with type parameters " << endl; 341 aggregate->params->printList( os, indent+4 ); 342 } 343 if( aggregate->actuals ) { 344 os << string( indent+2, ' ' ) << "instantiated with actual parameters " << endl; 345 aggregate->actuals->printList( os, indent+4 ); 346 } 347 if( aggregate->members ) { 348 os << string( indent+2, ' ' ) << "with members " << endl; 349 aggregate->members->printList( os, indent+4 ); 214 case Attr: 215 newtype->attr->expr = maybeClone( attr->expr ); 216 newtype->attr->type = maybeClone( attr->type ); 217 break; 218 } 219 return newtype; 220 } 221 222 void TypeData::print( std::ostream &os, int indent ) const { 223 using std::endl; 224 using std::string; 225 226 printEnums( qualifiers.begin(), qualifiers.end(), DeclarationNode::qualifierName, os ); 227 228 if ( forall ) { 229 os << "forall " << endl; 230 forall->printList( os, indent+4 ); 231 } 232 233 switch ( kind ) { 234 case Unknown: 235 os << "entity of unknown type "; 236 break; 237 case Pointer: 238 os << "pointer "; 239 if ( base ) { 240 os << "to "; 241 base->print( os, indent ); 242 } 243 break; 244 case EnumConstant: 245 os << "enumeration constant "; 246 break; 247 case Basic: 248 printEnums( basic->modifiers.begin(), basic->modifiers.end(), DeclarationNode::modifierName, os ); 249 printEnums( basic->typeSpec.begin(), basic->typeSpec.end(), DeclarationNode::basicTypeName, os ); 250 break; 251 case Array: 252 if ( array->isStatic ) { 253 os << "static "; 254 } 255 if ( array->dimension ) { 256 os << "array of "; 257 array->dimension->printOneLine( os, indent ); 258 } else if ( array->isVarLen ) { 259 os << "variable-length array of "; 260 } else { 261 os << "open array of "; 262 } 263 if ( base ) { 264 base->print( os, indent ); 265 } 266 break; 267 case Function: 268 os << "function" << endl; 269 if ( function->params ) { 270 os << string( indent+2, ' ' ) << "with parameters " << endl; 271 function->params->printList( os, indent+4 ); 272 } else { 273 os << string( indent+2, ' ' ) << "with no parameters " << endl; 274 } 275 if ( function->idList ) { 276 os << string( indent+2, ' ' ) << "with old-style identifier list " << endl; 277 function->idList->printList( os, indent+4 ); 278 } 279 if ( function->oldDeclList ) { 280 os << string( indent+2, ' ' ) << "with old-style declaration list " << endl; 281 function->oldDeclList->printList( os, indent+4 ); 282 } 283 os << string( indent+2, ' ' ) << "returning "; 284 if ( base ) { 285 base->print( os, indent+4 ); 286 } else { 287 os << "nothing "; 288 } 289 os << endl; 290 if ( function->hasBody ) { 291 os << string( indent+2, ' ' ) << "with body " << endl; 292 } 293 if ( function->body ) { 294 function->body->printList( os, indent+2 ); 295 } 296 break; 297 case Aggregate: 298 os << DeclarationNode::tyConName[ aggregate->kind ] << ' ' << aggregate->name << endl; 299 if ( aggregate->params ) { 300 os << string( indent+2, ' ' ) << "with type parameters " << endl; 301 aggregate->params->printList( os, indent+4 ); 302 } 303 if ( aggregate->actuals ) { 304 os << string( indent+2, ' ' ) << "instantiated with actual parameters " << endl; 305 aggregate->actuals->printList( os, indent+4 ); 306 } 307 if ( aggregate->members ) { 308 os << string( indent+2, ' ' ) << "with members " << endl; 309 aggregate->members->printList( os, indent+4 ); 350 310 /// } else { 351 311 /// os << string( indent+2, ' ' ) << "with no members " << endl; 352 } 353 break; 354 355 case AggregateInst: 356 if( aggInst->aggregate ) { 357 os << "instance of " ; 358 aggInst->aggregate->print( os, indent ); 312 } 313 break; 314 case AggregateInst: 315 if ( aggInst->aggregate ) { 316 os << "instance of " ; 317 aggInst->aggregate->print( os, indent ); 318 } else { 319 os << "instance of an unspecified aggregate "; 320 } 321 if ( aggInst->params ) { 322 os << string( indent+2, ' ' ) << "with parameters " << endl; 323 aggInst->params->printList( os, indent+2 ); 324 } 325 break; 326 case Enum: 327 os << "enumeration "; 328 if ( enumeration->constants ) { 329 os << "with constants" << endl; 330 enumeration->constants->printList( os, indent+2 ); 331 } 332 break; 333 case SymbolicInst: 334 os << "instance of type " << symbolic->name; 335 if ( symbolic->actuals ) { 336 os << " with parameters" << endl; 337 symbolic->actuals->printList( os, indent + 2 ); 338 } 339 break; 340 case Symbolic: 341 if ( symbolic->isTypedef ) { 342 os << "typedef definition "; 343 } else { 344 os << "type definition "; 345 } 346 if ( symbolic->params ) { 347 os << endl << string( indent+2, ' ' ) << "with parameters" << endl; 348 symbolic->params->printList( os, indent + 2 ); 349 } 350 if ( symbolic->assertions ) { 351 os << endl << string( indent+2, ' ' ) << "with assertions" << endl; 352 symbolic->assertions->printList( os, indent + 4 ); 353 os << string( indent+2, ' ' ); 354 } 355 if ( base ) { 356 os << "for "; 357 base->print( os, indent + 2 ); 358 } 359 break; 360 case Variable: 361 os << DeclarationNode::typeClassName[ variable->tyClass ] << " variable "; 362 if ( variable->assertions ) { 363 os << endl << string( indent+2, ' ' ) << "with assertions" << endl; 364 variable->assertions->printList( os, indent + 4 ); 365 os << string( indent+2, ' ' ); 366 } 367 break; 368 case Tuple: 369 os << "tuple "; 370 if ( tuple->members ) { 371 os << "with members " << endl; 372 tuple->members->printList( os, indent + 2 ); 373 } 374 break; 375 376 case Typeof: 377 os << "type-of expression "; 378 if ( typeexpr->expr ) { 379 typeexpr->expr->print( os, indent + 2 ); 380 } 381 break; 382 383 case Attr: 384 os << "attribute type decl " << attr->name << " applied to "; 385 if ( attr->expr ) { 386 attr->expr->print( os, indent + 2 ); 387 } 388 if ( attr->type ) { 389 attr->type->print( os, indent + 2 ); 390 } 391 break; 392 } 393 } 394 395 TypeData *TypeData::extractAggregate( bool toplevel ) const { 396 TypeData *ret = 0; 397 398 switch ( kind ) { 399 case Aggregate: 400 if ( !toplevel && aggregate->members ) { 401 ret = clone(); 402 ret->qualifiers.clear(); 403 } 404 break; 405 case Enum: 406 if ( !toplevel && enumeration->constants ) { 407 ret = clone(); 408 ret->qualifiers.clear(); 409 } 410 break; 411 case AggregateInst: 412 if ( aggInst->aggregate ) { 413 ret = aggInst->aggregate->extractAggregate( false ); 414 } 415 break; 416 default: 417 if ( base ) { 418 ret = base->extractAggregate( false ); 419 } 420 } 421 return ret; 422 } 423 424 void buildForall( const DeclarationNode *firstNode, std::list< TypeDecl* > &outputList ) { 425 426 buildList( firstNode, outputList ); 427 for ( std::list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) { 428 if ( (*i)->get_kind() == TypeDecl::Any ) { 429 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false ); 430 assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) ); 431 assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) ); 432 assignType->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) ); 433 (*i)->get_assertions().push_front( new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false ) ); 434 } 435 } 436 } 437 438 Declaration *TypeData::buildDecl( std::string name, Declaration::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init ) const { 439 if ( kind == TypeData::Function ) { 440 FunctionDecl *decl; 441 if ( function->hasBody ) { 442 if ( function->body ) { 443 Statement *stmt = function->body->build(); 444 CompoundStmt *body = dynamic_cast< CompoundStmt* >( stmt ); 445 assert( body ); 446 decl = new FunctionDecl( name, sc, linkage, buildFunction(), body, isInline ); 447 } else { 448 // std::list<Label> ls; 449 decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list<Label>() ), isInline ); 450 } 451 } else { 452 decl = new FunctionDecl( name, sc, linkage, buildFunction(), 0, isInline ); 453 } 454 for ( DeclarationNode *cur = function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_link() ) ) { 455 if ( cur->get_name() != "" ) { 456 decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() ); 457 } 458 } 459 buildList( function->oldDeclList, decl->get_oldDecls() ); 460 return decl; 461 } else if ( kind == TypeData::Aggregate ) { 462 return buildAggregate(); 463 } else if ( kind == TypeData::Enum ) { 464 return buildEnum(); 465 } else if ( kind == TypeData::Symbolic ) { 466 return buildSymbolic( name, sc ); 467 } else if ( kind == TypeData::Variable ) { 468 return buildVariable(); 359 469 } else { 360 os << "instance of an unspecified aggregate "; 361 } 362 if( aggInst->params ) { 363 os << string( indent+2, ' ' ) << "with parameters " << endl; 364 aggInst->params->printList( os, indent+2 ); 365 } 366 break; 367 368 case Enum: 369 os << "enumeration "; 370 if( enumeration->constants ) { 371 os << "with constants" << endl; 372 enumeration->constants->printList( os, indent+2 ); 373 } 374 break; 375 376 case SymbolicInst: 377 os << "instance of type " << symbolic->name; 378 if( symbolic->actuals ) { 379 os << " with parameters" << endl; 380 symbolic->actuals->printList( os, indent + 2 ); 381 } 382 break; 383 384 case Symbolic: 385 if( symbolic->isTypedef ) { 386 os << "typedef definition "; 470 if ( isInline ) { 471 throw SemanticError( "invalid inline specification in declaration of ", this ); 472 } else { 473 return new ObjectDecl( name, sc, linkage, bitfieldWidth, build(), init ); 474 } 475 } 476 return 0; 477 } 478 479 Type *TypeData::build() const { 480 481 switch ( kind ) { 482 case Unknown: 483 // fill in implicit int 484 return new BasicType( buildQualifiers(), BasicType::SignedInt ); 485 486 case Basic: 487 return buildBasicType(); 488 489 case Pointer: 490 return buildPointer(); 491 492 case Array: 493 return buildArray(); 494 495 case Function: 496 return buildFunction(); 497 498 case AggregateInst: 499 return buildAggInst(); 500 501 case EnumConstant: 502 // the name gets filled in later -- by SymTab::Validate 503 return new EnumInstType( buildQualifiers(), "" ); 504 505 case SymbolicInst: 506 return buildSymbolicInst();; 507 508 case Tuple: 509 return buildTuple(); 510 511 case Typeof: 512 return buildTypeof(); 513 514 case Attr: 515 return buildAttr(); 516 517 case Symbolic: 518 case Enum: 519 case Aggregate: 520 case Variable: 521 assert( false ); 522 } 523 524 return 0; 525 } 526 527 Type::Qualifiers TypeData::buildQualifiers() const { 528 Type::Qualifiers q; 529 for ( std::list< DeclarationNode::Qualifier >::const_iterator i = qualifiers.begin(); i != qualifiers.end(); ++i ) { 530 switch ( *i ) { 531 case DeclarationNode::Const: 532 q.isConst = true; 533 break; 534 case DeclarationNode::Volatile: 535 q.isVolatile = true; 536 break; 537 case DeclarationNode::Restrict: 538 q.isRestrict = true; 539 break; 540 case DeclarationNode::Lvalue: 541 q.isLvalue = true; 542 break; 543 } 544 } 545 return q; 546 } 547 548 Type *TypeData::buildBasicType() const { 549 static const BasicType::Kind kindMap[] = { BasicType::Char, BasicType::SignedInt, BasicType::Float, BasicType::Double, 550 BasicType::Char /* void */, BasicType::Bool, BasicType::DoubleComplex, 551 BasicType::DoubleImaginary }; 552 bool init = false; 553 bool sawDouble = false; 554 bool sawSigned = false; 555 BasicType::Kind ret; 556 557 for ( std::list< DeclarationNode::BasicType >::const_iterator i = basic->typeSpec.begin(); i != basic->typeSpec.end(); ++i ) { 558 if ( !init ) { 559 init = true; 560 if ( *i == DeclarationNode::Void ) { 561 if ( basic->typeSpec.size() != 1 || !basic->modifiers.empty() ) { 562 throw SemanticError( "invalid type specifier \"void\" in type ", this ); 563 } else { 564 return new VoidType( buildQualifiers() ); 565 } 566 } else { 567 ret = kindMap[ *i ]; 568 } 569 } else { 570 switch ( *i ) { 571 case DeclarationNode::Float: 572 if ( sawDouble ) { 573 throw SemanticError( "invalid type specifier \"float\" in type ", this ); 574 } else { 575 switch ( ret ) { 576 case BasicType::DoubleComplex: 577 ret = BasicType::FloatComplex; 578 break; 579 case BasicType::DoubleImaginary: 580 ret = BasicType::FloatImaginary; 581 break; 582 default: 583 throw SemanticError( "invalid type specifier \"float\" in type ", this ); 584 } 585 } 586 break; 587 case DeclarationNode::Double: 588 if ( sawDouble ) { 589 throw SemanticError( "duplicate type specifier \"double\" in type ", this ); 590 } else { 591 switch ( ret ) { 592 case BasicType::DoubleComplex: 593 case BasicType::DoubleImaginary: 594 break; 595 default: 596 throw SemanticError( "invalid type specifier \"double\" in type ", this ); 597 } 598 } 599 break; 600 601 case DeclarationNode::Complex: 602 switch ( ret ) { 603 case BasicType::Float: 604 ret = BasicType::FloatComplex; 605 break; 606 607 case BasicType::Double: 608 ret = BasicType::DoubleComplex; 609 break; 610 default: 611 throw SemanticError( "invalid type specifier \"complex\" in type ", this ); 612 } 613 break; 614 615 case DeclarationNode::Imaginary: 616 switch ( ret ) { 617 case BasicType::Float: 618 ret = BasicType::FloatImaginary; 619 break; 620 621 case BasicType::Double: 622 ret = BasicType::DoubleImaginary; 623 break; 624 default: 625 throw SemanticError( "invalid type specifier \"imaginary\" in type ", this ); 626 } 627 break; 628 629 default: 630 throw SemanticError( std::string( "invalid type specifier \"" ) + DeclarationNode::basicTypeName[ *i ] + "\" in type ", this ); 631 } 632 } 633 if ( *i == DeclarationNode::Double ) { 634 sawDouble = true; 635 } 636 } 637 638 for ( std::list< DeclarationNode::Modifier >::const_iterator i = basic->modifiers.begin(); i != basic->modifiers.end(); ++i ) { 639 switch ( *i ) { 640 case DeclarationNode::Long: 641 if ( !init ) { 642 init = true; 643 ret = BasicType::LongSignedInt; 644 } else { 645 switch ( ret ) { 646 case BasicType::SignedInt: 647 ret = BasicType::LongSignedInt; 648 break; 649 case BasicType::UnsignedInt: 650 ret = BasicType::LongUnsignedInt; 651 break; 652 case BasicType::LongSignedInt: 653 ret = BasicType::LongLongSignedInt; 654 break; 655 case BasicType::LongUnsignedInt: 656 ret = BasicType::LongLongUnsignedInt; 657 break; 658 case BasicType::Double: 659 ret = BasicType::LongDouble; 660 break; 661 case BasicType::DoubleComplex: 662 ret = BasicType::LongDoubleComplex; 663 break; 664 case BasicType::DoubleImaginary: 665 ret = BasicType::LongDoubleImaginary; 666 break; 667 default: 668 throw SemanticError( "invalid type modifier \"long\" in type ", this ); 669 } 670 } 671 break; 672 case DeclarationNode::Short: 673 if ( !init ) { 674 init = true; 675 ret = BasicType::ShortSignedInt; 676 } else { 677 switch ( ret ) { 678 case BasicType::SignedInt: 679 ret = BasicType::ShortSignedInt; 680 break; 681 case BasicType::UnsignedInt: 682 ret = BasicType::ShortUnsignedInt; 683 break; 684 default: 685 throw SemanticError( "invalid type modifier \"short\" in type ", this ); 686 } 687 } 688 break; 689 case DeclarationNode::Signed: 690 if ( !init ) { 691 init = true; 692 ret = BasicType::SignedInt; 693 } else if ( sawSigned ) { 694 throw SemanticError( "duplicate type modifer \"signed\" in type ", this ); 695 } else { 696 switch ( ret ) { 697 case BasicType::SignedInt: 698 case BasicType::ShortSignedInt: 699 break; 700 case BasicType::Char: 701 ret = BasicType::SignedChar; 702 break; 703 default: 704 throw SemanticError( "invalid type modifer \"signed\" in type ", this ); 705 } 706 } 707 break; 708 case DeclarationNode::Unsigned: 709 if ( !init ) { 710 init = true; 711 ret = BasicType::UnsignedInt; 712 } else if ( sawSigned ) { 713 throw SemanticError( "invalid type modifer \"unsigned\" in type ", this ); 714 } else { 715 switch ( ret ) { 716 case BasicType::LongSignedInt: 717 ret = BasicType::LongUnsignedInt; 718 break; 719 case BasicType::SignedInt: 720 ret = BasicType::UnsignedInt; 721 break; 722 case BasicType::ShortSignedInt: 723 ret = BasicType::ShortUnsignedInt; 724 break; 725 case BasicType::Char: 726 ret = BasicType::UnsignedChar; 727 break; 728 default: 729 throw SemanticError( "invalid type modifer \"unsigned\" in type ", this ); 730 } 731 } 732 break; 733 } 734 735 if ( *i == DeclarationNode::Signed ) { 736 sawSigned = true; 737 } 738 } 739 740 BasicType *bt; 741 if ( !init ) { 742 bt = new BasicType( buildQualifiers(), BasicType::SignedInt ); 387 743 } else { 388 os << "type definition "; 389 } 390 if( symbolic->params ) { 391 os << endl << string( indent+2, ' ' ) << "with parameters" << endl; 392 symbolic->params->printList( os, indent + 2 ); 393 } 394 if( symbolic->assertions ) { 395 os << endl << string( indent+2, ' ' ) << "with assertions" << endl; 396 symbolic->assertions->printList( os, indent + 4 ); 397 os << string( indent+2, ' ' ); 398 } 399 if( base ) { 400 os << "for "; 401 base->print( os, indent + 2 ); 402 } 403 break; 404 405 case Variable: 406 os << DeclarationNode::typeClassName[ variable->tyClass ] << " variable "; 407 if( variable->assertions ) { 408 os << endl << string( indent+2, ' ' ) << "with assertions" << endl; 409 variable->assertions->printList( os, indent + 4 ); 410 os << string( indent+2, ' ' ); 411 } 412 break; 413 414 case Tuple: 415 os << "tuple "; 416 if( tuple->members ) { 417 os << "with members " << endl; 418 tuple->members->printList( os, indent + 2 ); 419 } 420 break; 744 bt = new BasicType( buildQualifiers(), ret ); 745 } 746 buildForall( forall, bt->get_forall() ); 747 return bt; 748 } 749 750 751 PointerType *TypeData::buildPointer() const { 752 PointerType *pt; 753 if ( base ) { 754 pt = new PointerType( buildQualifiers(), base->build() ); 755 } else { 756 pt = new PointerType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ); 757 } 758 buildForall( forall, pt->get_forall() ); 759 return pt; 760 } 761 762 ArrayType *TypeData::buildArray() const { 763 764 ArrayType *at; 765 if ( base ) { 766 at = new ArrayType( buildQualifiers(), base->build(), maybeBuild< Expression >( array->dimension ), 767 array->isVarLen, array->isStatic ); 768 } else { 769 at = new ArrayType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 770 maybeBuild< Expression >( array->dimension ), array->isVarLen, array->isStatic ); 771 } 772 buildForall( forall, at->get_forall() ); 773 return at; 774 } 775 776 FunctionType *TypeData::buildFunction() const { 777 assert( kind == Function ); 778 bool hasEllipsis = function->params ? function->params->get_hasEllipsis() : true; 779 if ( !function->params ) hasEllipsis = !function->newStyle; 780 FunctionType *ft = new FunctionType( buildQualifiers(), hasEllipsis ); 781 buildList( function->params, ft->get_parameters() ); 782 buildForall( forall, ft->get_forall() ); 783 if ( base ) { 784 switch ( base->kind ) { 785 case Tuple: 786 buildList( base->tuple->members, ft->get_returnVals() ); 787 break; 788 default: 789 ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( base->buildDecl( "", Declaration::NoStorageClass, 0, false, LinkageSpec::Cforall ) ) ); 790 } 791 } else { 792 ft->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) ); 793 } 794 return ft; 795 } 796 797 AggregateDecl *TypeData::buildAggregate() const { 798 assert( kind == Aggregate ); 799 AggregateDecl *at; 800 switch ( aggregate->kind ) { 801 case DeclarationNode::Struct: 802 at = new StructDecl( aggregate->name ); 803 break; 421 804 422 case Typeof: 423 os << "type-of expression "; 424 if( typeexpr->expr ) { 425 typeexpr->expr->print( os, indent + 2 ); 426 } 427 break; 805 case DeclarationNode::Union: 806 at = new UnionDecl( aggregate->name ); 807 break; 428 808 429 case Attr: 430 os << "attribute type decl " << attr->name << " applied to "; 431 if( attr->expr ) { 432 attr->expr->print( os, indent + 2 ); 433 } 434 if( attr->type ) { 435 attr->type->print( os, indent + 2 ); 436 } 437 break; 438 } 439 } 440 441 TypeData * 442 TypeData::extractAggregate( bool toplevel ) const 443 { 444 TypeData *ret = 0; 445 446 switch( kind ) { 447 case Aggregate: 448 if( !toplevel && aggregate->members ) { 449 ret = clone(); 450 ret->qualifiers.clear(); 451 } 452 break; 453 454 case Enum: 455 if( !toplevel && enumeration->constants ) { 456 ret = clone(); 457 ret->qualifiers.clear(); 458 } 459 break; 460 461 case AggregateInst: 462 if( aggInst->aggregate ) { 463 ret = aggInst->aggregate->extractAggregate( false ); 464 } 465 break; 466 467 default: 468 if( base ) { 469 ret = base->extractAggregate( false ); 470 } 471 } 472 return ret; 473 } 474 475 void 476 buildForall( const DeclarationNode *firstNode, std::list< TypeDecl* > &outputList ) 477 { 809 case DeclarationNode::Context: 810 at = new ContextDecl( aggregate->name ); 811 break; 812 813 default: 814 assert( false ); 815 } 478 816 479 buildList( firstNode, outputList ); 480 for( std::list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) { 481 if( (*i)->get_kind() == TypeDecl::Any ) { 482 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false ); 483 assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) ); 484 assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) ); 485 assignType->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) ); 486 (*i)->get_assertions().push_front( new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false ) ); 487 } 488 } 489 } 490 491 Declaration * 492 TypeData::buildDecl( std::string name, Declaration::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init ) const 493 { 494 495 if ( kind == TypeData::Function ) { 496 FunctionDecl *decl; 497 if( function->hasBody ) { 498 if( function->body ) { 499 Statement *stmt = function->body->build(); 500 CompoundStmt *body = dynamic_cast< CompoundStmt* >( stmt ); 501 assert( body ); 502 decl = new FunctionDecl( name, sc, linkage, buildFunction(), body, isInline ); 503 } else { 504 // std::list<Label> ls; 505 decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list<Label>() ), isInline ); 506 } 507 } else { 508 decl = new FunctionDecl( name, sc, linkage, buildFunction(), 0, isInline ); 509 } 510 for( DeclarationNode *cur = function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_link() ) ) { 511 if( cur->get_name() != "" ) { 512 decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() ); 513 } 514 } 515 buildList( function->oldDeclList, decl->get_oldDecls() ); 516 return decl; 517 } else if ( kind == TypeData::Aggregate ) { 518 return buildAggregate(); 519 } else if ( kind == TypeData::Enum ) { 520 return buildEnum(); 521 } else if ( kind == TypeData::Symbolic ) { 522 return buildSymbolic( name, sc ); 523 } else if ( kind == TypeData::Variable ) { 524 return buildVariable(); 525 } else { 526 if( isInline ) { 527 throw SemanticError( "invalid inline specification in declaration of ", this ); 528 } else { 529 return new ObjectDecl( name, sc, linkage, bitfieldWidth, build(), init ); 530 } 531 } 532 return 0; 533 } 534 535 Type * 536 TypeData::build() const 537 { 538 539 switch( kind ) { 540 case Unknown: 541 // fill in implicit int 542 return new BasicType( buildQualifiers(), BasicType::SignedInt ); 543 544 case Basic: 545 return buildBasicType(); 546 547 case Pointer: 548 return buildPointer(); 549 550 case Array: 551 return buildArray(); 552 553 case Function: 554 return buildFunction(); 555 556 case AggregateInst: 557 return buildAggInst(); 558 559 case EnumConstant: 560 // the name gets filled in later -- by SymTab::Validate 561 return new EnumInstType( buildQualifiers(), "" ); 562 563 case SymbolicInst: 564 return buildSymbolicInst();; 565 566 case Tuple: 567 return buildTuple(); 568 569 case Typeof: 570 return buildTypeof(); 571 572 case Attr: 573 return buildAttr(); 574 575 case Symbolic: 576 case Enum: 577 case Aggregate: 578 case Variable: 579 assert( false ); 580 } 581 582 return 0; 583 } 584 585 Type::Qualifiers 586 TypeData::buildQualifiers() const 587 { 588 Type::Qualifiers q; 589 for( std::list< DeclarationNode::Qualifier >::const_iterator i = qualifiers.begin(); i != qualifiers.end(); ++i ) { 590 switch( *i ) { 591 case DeclarationNode::Const: 592 q.isConst = true; 593 break; 594 595 case DeclarationNode::Volatile: 596 q.isVolatile = true; 597 break; 598 599 case DeclarationNode::Restrict: 600 q.isRestrict = true; 601 break; 602 603 case DeclarationNode::Lvalue: 604 q.isLvalue = true; 605 break; 606 } 607 } 608 return q; 609 } 610 611 Type* 612 TypeData::buildBasicType() const 613 { 614 615 static const BasicType::Kind kindMap[] = { BasicType::Char, BasicType::SignedInt, BasicType::Float, BasicType::Double, 616 BasicType::Char /* void */, BasicType::Bool, BasicType::DoubleComplex, 617 BasicType::DoubleImaginary }; 618 619 bool init = false; 620 bool sawDouble = false; 621 bool sawSigned = false; 622 BasicType::Kind ret; 623 624 for( std::list< DeclarationNode::BasicType >::const_iterator i = basic->typeSpec.begin(); i != basic->typeSpec.end(); ++i ) { 625 if( !init ) { 626 init = true; 627 if( *i == DeclarationNode::Void ) { 628 if( basic->typeSpec.size() != 1 || !basic->modifiers.empty() ) { 629 throw SemanticError( "invalid type specifier \"void\" in type ", this ); 630 } else { 631 return new VoidType( buildQualifiers() ); 632 } 633 } else { 634 ret = kindMap[ *i ]; 635 } 636 } else { 637 switch( *i ) { 638 case DeclarationNode::Float: 639 if( sawDouble ) { 640 throw SemanticError( "invalid type specifier \"float\" in type ", this ); 641 } else { 642 switch( ret ) { 643 case BasicType::DoubleComplex: 644 ret = BasicType::FloatComplex; 645 break; 646 647 case BasicType::DoubleImaginary: 648 ret = BasicType::FloatImaginary; 649 break; 650 651 default: 652 throw SemanticError( "invalid type specifier \"float\" in type ", this ); 653 } 654 } 655 break; 656 657 case DeclarationNode::Double: 658 if( sawDouble ) { 659 throw SemanticError( "duplicate type specifier \"double\" in type ", this ); 660 } else { 661 switch( ret ) { 662 case BasicType::DoubleComplex: 663 case BasicType::DoubleImaginary: 664 break; 665 666 default: 667 throw SemanticError( "invalid type specifier \"double\" in type ", this ); 668 } 669 } 670 break; 671 672 case DeclarationNode::Complex: 673 switch( ret ) { 674 case BasicType::Float: 675 ret = BasicType::FloatComplex; 676 break; 677 678 case BasicType::Double: 679 ret = BasicType::DoubleComplex; 680 break; 681 682 default: 683 throw SemanticError( "invalid type specifier \"complex\" in type ", this ); 684 } 685 break; 686 687 case DeclarationNode::Imaginary: 688 switch( ret ) { 689 case BasicType::Float: 690 ret = BasicType::FloatImaginary; 691 break; 692 693 case BasicType::Double: 694 ret = BasicType::DoubleImaginary; 695 break; 696 697 default: 698 throw SemanticError( "invalid type specifier \"imaginary\" in type ", this ); 699 } 700 break; 701 702 default: 703 throw SemanticError( std::string( "invalid type specifier \"" ) + DeclarationNode::basicTypeName[ *i ] + "\" in type ", this ); 704 } 705 } 706 if( *i == DeclarationNode::Double ) { 707 sawDouble = true; 708 } 709 } 710 711 for( std::list< DeclarationNode::Modifier >::const_iterator i = basic->modifiers.begin(); i != basic->modifiers.end(); ++i ) { 712 switch( *i ) { 713 case DeclarationNode::Long: 714 if( !init ) { 715 init = true; 716 ret = BasicType::LongSignedInt; 717 } else { 718 switch( ret ) { 719 case BasicType::SignedInt: 720 ret = BasicType::LongSignedInt; 721 break; 722 723 case BasicType::UnsignedInt: 724 ret = BasicType::LongUnsignedInt; 725 break; 726 727 case BasicType::LongSignedInt: 728 ret = BasicType::LongLongSignedInt; 729 break; 730 731 case BasicType::LongUnsignedInt: 732 ret = BasicType::LongLongUnsignedInt; 733 break; 734 735 case BasicType::Double: 736 ret = BasicType::LongDouble; 737 break; 738 739 case BasicType::DoubleComplex: 740 ret = BasicType::LongDoubleComplex; 741 break; 742 743 case BasicType::DoubleImaginary: 744 ret = BasicType::LongDoubleImaginary; 745 break; 746 747 default: 748 throw SemanticError( "invalid type modifier \"long\" in type ", this ); 749 } 750 } 751 break; 752 753 case DeclarationNode::Short: 754 if( !init ) { 755 init = true; 756 ret = BasicType::ShortSignedInt; 757 } else { 758 switch( ret ) { 759 case BasicType::SignedInt: 760 ret = BasicType::ShortSignedInt; 761 break; 762 763 case BasicType::UnsignedInt: 764 ret = BasicType::ShortUnsignedInt; 765 break; 766 767 default: 768 throw SemanticError( "invalid type modifier \"short\" in type ", this ); 769 } 770 } 771 break; 772 773 case DeclarationNode::Signed: 774 if( !init ) { 775 init = true; 776 ret = BasicType::SignedInt; 777 } else if( sawSigned ) { 778 throw SemanticError( "duplicate type modifer \"signed\" in type ", this ); 779 } else { 780 switch( ret ) { 781 case BasicType::SignedInt: 782 case BasicType::ShortSignedInt: 783 break; 784 785 case BasicType::Char: 786 ret = BasicType::SignedChar; 787 break; 788 789 default: 790 throw SemanticError( "invalid type modifer \"signed\" in type ", this ); 791 } 792 } 793 break; 794 795 case DeclarationNode::Unsigned: 796 if( !init ) { 797 init = true; 798 ret = BasicType::UnsignedInt; 799 } else if( sawSigned ) { 800 throw SemanticError( "invalid type modifer \"unsigned\" in type ", this ); 801 } else { 802 switch( ret ) { 803 case BasicType::LongSignedInt: 804 ret = BasicType::LongUnsignedInt; 805 break; 806 807 case BasicType::SignedInt: 808 ret = BasicType::UnsignedInt; 809 break; 810 811 case BasicType::ShortSignedInt: 812 ret = BasicType::ShortUnsignedInt; 813 break; 814 815 case BasicType::Char: 816 ret = BasicType::UnsignedChar; 817 break; 818 819 default: 820 throw SemanticError( "invalid type modifer \"unsigned\" in type ", this ); 821 } 822 } 823 break; 824 } 825 826 if( *i == DeclarationNode::Signed ) { 827 sawSigned = true; 828 } 829 } 830 831 BasicType *bt; 832 if( !init ) { 833 bt = new BasicType( buildQualifiers(), BasicType::SignedInt ); 834 } else { 835 bt = new BasicType( buildQualifiers(), ret ); 836 } 837 buildForall( forall, bt->get_forall() ); 838 return bt; 839 } 840 841 842 PointerType * 843 TypeData::buildPointer() const 844 { 845 846 PointerType *pt; 847 if( base ) { 848 pt = new PointerType( buildQualifiers(), base->build() ); 849 } else { 850 pt = new PointerType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ); 851 } 852 buildForall( forall, pt->get_forall() ); 853 return pt; 854 } 855 856 ArrayType * 857 TypeData::buildArray() const 858 { 859 860 ArrayType *at; 861 if( base ) { 862 at = new ArrayType( buildQualifiers(), base->build(), maybeBuild< Expression >( array->dimension ), 863 array->isVarLen, array->isStatic ); 864 } else { 865 at = new ArrayType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 866 maybeBuild< Expression >( array->dimension ), array->isVarLen, array->isStatic ); 867 } 868 buildForall( forall, at->get_forall() ); 869 return at; 870 } 871 872 FunctionType * 873 TypeData::buildFunction() const 874 { 875 assert( kind == Function ); 876 877 878 bool hasEllipsis = function->params ? function->params->get_hasEllipsis() : true; 879 if( !function->params ) hasEllipsis = !function->newStyle; 880 FunctionType *ft = new FunctionType( buildQualifiers(), hasEllipsis ); 881 buildList( function->params, ft->get_parameters() ); 882 buildForall( forall, ft->get_forall() ); 883 if( base ) { 884 switch( base->kind ) { 885 case Tuple: 886 buildList( base->tuple->members, ft->get_returnVals() ); 887 break; 888 889 default: 890 ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( base->buildDecl( "", Declaration::NoStorageClass, 0, false, LinkageSpec::Cforall ) ) ); 891 } 892 } else { 893 ft->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) ); 894 } 895 return ft; 896 } 897 898 AggregateDecl * 899 TypeData::buildAggregate() const 900 { 901 assert( kind == Aggregate ); 902 903 904 AggregateDecl *at; 905 switch( aggregate->kind ) { 906 case DeclarationNode::Struct: 907 at = new StructDecl( aggregate->name ); 908 break; 909 910 case DeclarationNode::Union: 911 at = new UnionDecl( aggregate->name ); 912 break; 913 914 case DeclarationNode::Context: 915 at = new ContextDecl( aggregate->name ); 916 break; 917 918 default: 919 assert( false ); 920 } 921 922 buildList( aggregate->params, at->get_parameters() ); 923 buildList( aggregate->members, at->get_members() ); 924 925 return at; 817 buildList( aggregate->params, at->get_parameters() ); 818 buildList( aggregate->members, at->get_members() ); 819 820 return at; 926 821 } 927 822 … … 930 825 /// makeType( Declaration* decl ) 931 826 /// { 932 /// if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {827 /// if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) { 933 828 /// return dwt->get_type()->clone(); 934 829 /// } else { … … 938 833 /// } 939 834 940 ReferenceToType * 941 TypeData::buildAggInst() const 942 { 943 assert( kind == AggregateInst ); 944 945 946 std::string name; 947 948 ReferenceToType *ret; 949 if( aggInst->aggregate->kind == Enum ) { 950 ret = new EnumInstType( buildQualifiers(), aggInst->aggregate->enumeration->name ); 951 } else { 952 assert( aggInst->aggregate->kind == Aggregate ); 953 switch( aggInst->aggregate->aggregate->kind ) { 954 case DeclarationNode::Struct: 955 ret = new StructInstType( buildQualifiers(), aggInst->aggregate->aggregate->name ); 956 break; 957 958 case DeclarationNode::Union: 959 ret = new UnionInstType( buildQualifiers(), aggInst->aggregate->aggregate->name ); 960 break; 961 962 case DeclarationNode::Context: 963 ret = new ContextInstType( buildQualifiers(), aggInst->aggregate->aggregate->name ); 964 break; 965 966 default: 967 assert( false ); 968 } 969 } 970 buildList( aggInst->params, ret->get_parameters() ); 971 buildForall( forall, ret->get_forall() ); 972 return ret; 973 } 974 975 NamedTypeDecl* 976 TypeData::buildSymbolic( const std::string &name, Declaration::StorageClass sc ) const 977 { 978 assert( kind == Symbolic ); 979 980 981 NamedTypeDecl *ret; 982 if( symbolic->isTypedef ) { 983 ret = new TypedefDecl( name, sc, maybeBuild< Type >( base ) ); 984 } else { 985 ret = new TypeDecl( name, sc, maybeBuild< Type >( base ), TypeDecl::Any ); 986 } 987 buildList( symbolic->params, ret->get_parameters() ); 988 buildList( symbolic->assertions, ret->get_assertions() ); 989 return ret; 990 } 991 992 TypeDecl* 993 TypeData::buildVariable() const 994 { 995 assert( kind == Variable ); 996 997 998 static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype }; 999 1000 TypeDecl *ret = new TypeDecl( variable->name, Declaration::NoStorageClass, 0, kindMap[ variable->tyClass ] ); 1001 buildList( variable->assertions, ret->get_assertions() ); 835 ReferenceToType *TypeData::buildAggInst() const { 836 assert( kind == AggregateInst ); 837 std::string name; 838 839 ReferenceToType *ret; 840 if ( aggInst->aggregate->kind == Enum ) { 841 ret = new EnumInstType( buildQualifiers(), aggInst->aggregate->enumeration->name ); 842 } else { 843 assert( aggInst->aggregate->kind == Aggregate ); 844 switch ( aggInst->aggregate->aggregate->kind ) { 845 case DeclarationNode::Struct: 846 ret = new StructInstType( buildQualifiers(), aggInst->aggregate->aggregate->name ); 847 break; 848 case DeclarationNode::Union: 849 ret = new UnionInstType( buildQualifiers(), aggInst->aggregate->aggregate->name ); 850 break; 851 case DeclarationNode::Context: 852 ret = new ContextInstType( buildQualifiers(), aggInst->aggregate->aggregate->name ); 853 break; 854 default: 855 assert( false ); 856 } 857 } 858 buildList( aggInst->params, ret->get_parameters() ); 859 buildForall( forall, ret->get_forall() ); 860 return ret; 861 } 862 863 NamedTypeDecl *TypeData::buildSymbolic( const std::string &name, Declaration::StorageClass sc ) const { 864 assert( kind == Symbolic ); 865 NamedTypeDecl *ret; 866 if ( symbolic->isTypedef ) { 867 ret = new TypedefDecl( name, sc, maybeBuild< Type >( base ) ); 868 } else { 869 ret = new TypeDecl( name, sc, maybeBuild< Type >( base ), TypeDecl::Any ); 870 } 871 buildList( symbolic->params, ret->get_parameters() ); 872 buildList( symbolic->assertions, ret->get_assertions() ); 873 return ret; 874 } 875 876 TypeDecl *TypeData::buildVariable() const { 877 assert( kind == Variable ); 878 static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype }; 879 880 TypeDecl *ret = new TypeDecl( variable->name, Declaration::NoStorageClass, 0, kindMap[ variable->tyClass ] ); 881 buildList( variable->assertions, ret->get_assertions() ); 1002 882 1003 return ret; 1004 } 1005 1006 EnumDecl* 1007 TypeData::buildEnum() const 1008 { 1009 assert( kind == Enum ); 1010 1011 1012 EnumDecl *ret = new EnumDecl( enumeration->name ); 1013 buildList( enumeration->constants, ret->get_members() ); 1014 1015 return ret; 1016 } 1017 1018 TypeInstType * 1019 TypeData::buildSymbolicInst() const 1020 { 1021 assert( kind == SymbolicInst ); 1022 1023 1024 TypeInstType *ret = new TypeInstType( buildQualifiers(), symbolic->name, false ); 1025 buildList( symbolic->actuals, ret->get_parameters() ); 1026 buildForall( forall, ret->get_forall() ); 1027 1028 return ret; 1029 } 1030 1031 TupleType * 1032 TypeData::buildTuple() const 1033 { 1034 assert( kind == Tuple ); 1035 1036 1037 TupleType *ret = new TupleType( buildQualifiers() ); 1038 buildTypeList( tuple->members, ret->get_types() ); 1039 buildForall( forall, ret->get_forall() ); 1040 1041 return ret; 1042 } 1043 1044 TypeofType * 1045 TypeData::buildTypeof() const 1046 { 1047 assert( kind == Typeof ); 1048 1049 1050 assert( typeexpr ); 1051 assert( typeexpr->expr ); 1052 TypeofType *ret = new TypeofType( buildQualifiers(), typeexpr->expr->build() ); 1053 1054 return ret; 1055 } 1056 1057 AttrType * 1058 TypeData::buildAttr() const 1059 { 1060 assert( kind == Attr ); 1061 1062 1063 assert( attr ); 1064 AttrType *ret; 1065 if( attr->expr ) { 1066 ret = new AttrType( buildQualifiers(), attr->name, attr->expr->build() ); 1067 } else { 1068 assert( attr->type ); 1069 ret = new AttrType( buildQualifiers(), attr->name, attr->type->buildType() ); 1070 } 1071 1072 return ret; 1073 } 1074 883 return ret; 884 } 885 886 EnumDecl *TypeData::buildEnum() const { 887 assert( kind == Enum ); 888 EnumDecl *ret = new EnumDecl( enumeration->name ); 889 buildList( enumeration->constants, ret->get_members() ); 890 891 return ret; 892 } 893 894 TypeInstType *TypeData::buildSymbolicInst() const { 895 assert( kind == SymbolicInst ); 896 897 898 TypeInstType *ret = new TypeInstType( buildQualifiers(), symbolic->name, false ); 899 buildList( symbolic->actuals, ret->get_parameters() ); 900 buildForall( forall, ret->get_forall() ); 901 902 return ret; 903 } 904 905 TupleType *TypeData::buildTuple() const { 906 assert( kind == Tuple ); 907 908 909 TupleType *ret = new TupleType( buildQualifiers() ); 910 buildTypeList( tuple->members, ret->get_types() ); 911 buildForall( forall, ret->get_forall() ); 912 913 return ret; 914 } 915 916 TypeofType *TypeData::buildTypeof() const { 917 assert( kind == Typeof ); 918 assert( typeexpr ); 919 assert( typeexpr->expr ); 920 TypeofType *ret = new TypeofType( buildQualifiers(), typeexpr->expr->build() ); 921 922 return ret; 923 } 924 925 AttrType *TypeData::buildAttr() const { 926 assert( kind == Attr ); 927 assert( attr ); 928 AttrType *ret; 929 if ( attr->expr ) { 930 ret = new AttrType( buildQualifiers(), attr->name, attr->expr->build() ); 931 } else { 932 assert( attr->type ); 933 ret = new AttrType( buildQualifiers(), attr->name, attr->type->buildType() ); 934 } 935 936 return ret; 937 }
Note: See TracChangeset
for help on using the changeset viewer.