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