Changeset a32b204 for translator/ResolvExpr/Resolver.cc
- Timestamp:
- May 17, 2015, 1:19:35 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:
- 0dd3a2f
- Parents:
- b87a5ed
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
translator/ResolvExpr/Resolver.cc
rb87a5ed ra32b204 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 // Resolver.cc -- 8 // 9 // Author : Richard C. Bilson 10 // Created On : Sun May 17 12:17:01 2015 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Sun May 17 12:18:17 2015 13 // Update Count : 2 14 // 15 1 16 #include "Resolver.h" 2 17 #include "AlternativeFinder.h" … … 15 30 16 31 namespace ResolvExpr { 17 class Resolver : public SymTab::Indexer { 18 public: 19 Resolver() : SymTab::Indexer( false ), switchType( 0 ) {} 20 21 virtual void visit( FunctionDecl *functionDecl ); 22 virtual void visit( ObjectDecl *functionDecl ); 23 virtual void visit( TypeDecl *typeDecl ); 24 25 virtual void visit( ExprStmt *exprStmt ); 26 virtual void visit( IfStmt *ifStmt ); 27 virtual void visit( WhileStmt *whileStmt ); 28 virtual void visit( ForStmt *forStmt ); 29 virtual void visit( SwitchStmt *switchStmt ); 30 virtual void visit( ChooseStmt *switchStmt ); 31 virtual void visit( CaseStmt *caseStmt ); 32 virtual void visit( ReturnStmt *returnStmt ); 33 34 virtual void visit( SingleInit *singleInit ); 35 virtual void visit( ListInit *listInit ); 36 private: 37 std::list< Type * > functionReturn; 38 Type *initContext; 39 Type *switchType; 40 }; 41 42 void resolve( std::list< Declaration * > translationUnit ) { 43 Resolver resolver; 44 acceptAll( translationUnit, resolver ); 45 #if 0 46 resolver.print( cerr ); 47 for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) { 48 (*i)->print( std::cerr ); 49 (*i)->accept( resolver ); 50 } // for 51 #endif 52 } 53 54 Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) { 55 TypeEnvironment env; 56 return resolveInVoidContext( expr, indexer, env ); 57 } 58 59 namespace { 60 void finishExpr( Expression *expr, const TypeEnvironment &env ) { 61 expr->set_env( new TypeSubstitution ); 62 env.makeSubstitution( *expr->get_env() ); 63 } 64 65 Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) { 66 global_renamer.reset(); 67 TypeEnvironment env; 68 Expression *newExpr = resolveInVoidContext( untyped, indexer, env ); 69 finishExpr( newExpr, env ); 70 return newExpr; 71 } 72 73 Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) { 74 TypeEnvironment env; 75 AlternativeFinder finder( indexer, env ); 76 finder.find( untyped ); 77 #if 0 78 if ( finder.get_alternatives().size() != 1 ) { 79 std::cout << "untyped expr is "; 80 untyped->print( std::cout ); 81 std::cout << std::endl << "alternatives are:"; 82 for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { 83 i->print( std::cout ); 32 class Resolver : public SymTab::Indexer { 33 public: 34 Resolver() : SymTab::Indexer( false ), switchType( 0 ) {} 35 36 virtual void visit( FunctionDecl *functionDecl ); 37 virtual void visit( ObjectDecl *functionDecl ); 38 virtual void visit( TypeDecl *typeDecl ); 39 40 virtual void visit( ExprStmt *exprStmt ); 41 virtual void visit( IfStmt *ifStmt ); 42 virtual void visit( WhileStmt *whileStmt ); 43 virtual void visit( ForStmt *forStmt ); 44 virtual void visit( SwitchStmt *switchStmt ); 45 virtual void visit( ChooseStmt *switchStmt ); 46 virtual void visit( CaseStmt *caseStmt ); 47 virtual void visit( ReturnStmt *returnStmt ); 48 49 virtual void visit( SingleInit *singleInit ); 50 virtual void visit( ListInit *listInit ); 51 private: 52 std::list< Type * > functionReturn; 53 Type *initContext; 54 Type *switchType; 55 }; 56 57 void resolve( std::list< Declaration * > translationUnit ) { 58 Resolver resolver; 59 acceptAll( translationUnit, resolver ); 60 #if 0 61 resolver.print( cerr ); 62 for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) { 63 (*i)->print( std::cerr ); 64 (*i)->accept( resolver ); 84 65 } // for 85 } // if 86 #endif 87 assert( finder.get_alternatives().size() == 1 ); 88 Alternative &choice = finder.get_alternatives().front(); 89 Expression *newExpr = choice.expr->clone(); 90 finishExpr( newExpr, choice.env ); 91 return newExpr; 92 } 93 94 bool isIntegralType( Type *type ) { 95 if ( dynamic_cast< EnumInstType * >( type ) ) { 96 return true; 97 } else if ( BasicType *bt = dynamic_cast< BasicType * >( type ) ) { 98 return bt->isInteger(); 99 } else { 100 return false; 101 } // if 102 } 103 104 Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) { 105 TypeEnvironment env; 106 AlternativeFinder finder( indexer, env ); 107 finder.find( untyped ); 108 #if 0 109 if ( finder.get_alternatives().size() != 1 ) { 110 std::cout << "untyped expr is "; 111 untyped->print( std::cout ); 112 std::cout << std::endl << "alternatives are:"; 113 for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { 114 i->print( std::cout ); 66 #endif 67 } 68 69 Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) { 70 TypeEnvironment env; 71 return resolveInVoidContext( expr, indexer, env ); 72 } 73 74 namespace { 75 void finishExpr( Expression *expr, const TypeEnvironment &env ) { 76 expr->set_env( new TypeSubstitution ); 77 env.makeSubstitution( *expr->get_env() ); 78 } 79 80 Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) { 81 global_renamer.reset(); 82 TypeEnvironment env; 83 Expression *newExpr = resolveInVoidContext( untyped, indexer, env ); 84 finishExpr( newExpr, env ); 85 return newExpr; 86 } 87 88 Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) { 89 TypeEnvironment env; 90 AlternativeFinder finder( indexer, env ); 91 finder.find( untyped ); 92 #if 0 93 if ( finder.get_alternatives().size() != 1 ) { 94 std::cout << "untyped expr is "; 95 untyped->print( std::cout ); 96 std::cout << std::endl << "alternatives are:"; 97 for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { 98 i->print( std::cout ); 99 } // for 100 } // if 101 #endif 102 assert( finder.get_alternatives().size() == 1 ); 103 Alternative &choice = finder.get_alternatives().front(); 104 Expression *newExpr = choice.expr->clone(); 105 finishExpr( newExpr, choice.env ); 106 return newExpr; 107 } 108 109 bool isIntegralType( Type *type ) { 110 if ( dynamic_cast< EnumInstType * >( type ) ) { 111 return true; 112 } else if ( BasicType *bt = dynamic_cast< BasicType * >( type ) ) { 113 return bt->isInteger(); 114 } else { 115 return false; 116 } // if 117 } 118 119 Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) { 120 TypeEnvironment env; 121 AlternativeFinder finder( indexer, env ); 122 finder.find( untyped ); 123 #if 0 124 if ( finder.get_alternatives().size() != 1 ) { 125 std::cout << "untyped expr is "; 126 untyped->print( std::cout ); 127 std::cout << std::endl << "alternatives are:"; 128 for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { 129 i->print( std::cout ); 130 } // for 131 } // if 132 #endif 133 Expression *newExpr = 0; 134 const TypeEnvironment *newEnv = 0; 135 for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { 136 if ( i->expr->get_results().size() == 1 && isIntegralType( i->expr->get_results().front() ) ) { 137 if ( newExpr ) { 138 throw SemanticError( "Too many interpretations for case control expression", untyped ); 139 } else { 140 newExpr = i->expr->clone(); 141 newEnv = &i->env; 142 } // if 143 } // if 144 } // for 145 if ( ! newExpr ) { 146 throw SemanticError( "No interpretations for case control expression", untyped ); 147 } // if 148 finishExpr( newExpr, *newEnv ); 149 return newExpr; 150 } 151 152 } 153 154 void Resolver::visit( ObjectDecl *objectDecl ) { 155 Type *new_type = resolveTypeof( objectDecl->get_type(), *this ); 156 objectDecl->set_type( new_type ); 157 initContext = new_type; 158 SymTab::Indexer::visit( objectDecl ); 159 } 160 161 void Resolver::visit( TypeDecl *typeDecl ) { 162 if ( typeDecl->get_base() ) { 163 Type *new_type = resolveTypeof( typeDecl->get_base(), *this ); 164 typeDecl->set_base( new_type ); 165 } // if 166 SymTab::Indexer::visit( typeDecl ); 167 } 168 169 void Resolver::visit( FunctionDecl *functionDecl ) { 170 #if 0 171 std::cout << "resolver visiting functiondecl "; 172 functionDecl->print( std::cout ); 173 std::cout << std::endl; 174 #endif 175 Type *new_type = resolveTypeof( functionDecl->get_type(), *this ); 176 functionDecl->set_type( new_type ); 177 std::list< Type * > oldFunctionReturn = functionReturn; 178 functionReturn.clear(); 179 for ( std::list< DeclarationWithType * >::const_iterator i = functionDecl->get_functionType()->get_returnVals().begin(); i != functionDecl->get_functionType()->get_returnVals().end(); ++i ) { 180 functionReturn.push_back( (*i)->get_type() ); 115 181 } // for 116 } // if 117 #endif 118 Expression *newExpr = 0; 119 const TypeEnvironment *newEnv = 0; 120 for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { 121 if ( i->expr->get_results().size() == 1 && isIntegralType( i->expr->get_results().front() ) ) { 122 if ( newExpr ) { 123 throw SemanticError( "Too many interpretations for case control expression", untyped ); 124 } else { 125 newExpr = i->expr->clone(); 126 newEnv = &i->env; 127 } // if 128 } // if 129 } // for 130 if ( ! newExpr ) { 131 throw SemanticError( "No interpretations for case control expression", untyped ); 132 } // if 133 finishExpr( newExpr, *newEnv ); 134 return newExpr; 135 } 136 137 } 138 139 void Resolver::visit( ObjectDecl *objectDecl ) { 140 Type *new_type = resolveTypeof( objectDecl->get_type(), *this ); 141 objectDecl->set_type( new_type ); 142 initContext = new_type; 143 SymTab::Indexer::visit( objectDecl ); 144 } 145 146 void Resolver::visit( TypeDecl *typeDecl ) { 147 if ( typeDecl->get_base() ) { 148 Type *new_type = resolveTypeof( typeDecl->get_base(), *this ); 149 typeDecl->set_base( new_type ); 150 } // if 151 SymTab::Indexer::visit( typeDecl ); 152 } 153 154 void Resolver::visit( FunctionDecl *functionDecl ) { 155 #if 0 156 std::cout << "resolver visiting functiondecl "; 157 functionDecl->print( std::cout ); 158 std::cout << std::endl; 159 #endif 160 Type *new_type = resolveTypeof( functionDecl->get_type(), *this ); 161 functionDecl->set_type( new_type ); 162 std::list< Type * > oldFunctionReturn = functionReturn; 163 functionReturn.clear(); 164 for ( std::list< DeclarationWithType * >::const_iterator i = functionDecl->get_functionType()->get_returnVals().begin(); i != functionDecl->get_functionType()->get_returnVals().end(); ++i ) { 165 functionReturn.push_back( (*i)->get_type() ); 166 } // for 167 SymTab::Indexer::visit( functionDecl ); 168 functionReturn = oldFunctionReturn; 169 } 170 171 void Resolver::visit( ExprStmt *exprStmt ) { 172 if ( exprStmt->get_expr() ) { 173 Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this ); 174 delete exprStmt->get_expr(); 175 exprStmt->set_expr( newExpr ); 176 } // if 177 } 178 179 void Resolver::visit( IfStmt *ifStmt ) { 180 Expression *newExpr = findSingleExpression( ifStmt->get_condition(), *this ); 181 delete ifStmt->get_condition(); 182 ifStmt->set_condition( newExpr ); 183 Visitor::visit( ifStmt ); 184 } 185 186 void Resolver::visit( WhileStmt *whileStmt ) { 187 Expression *newExpr = findSingleExpression( whileStmt->get_condition(), *this ); 188 delete whileStmt->get_condition(); 189 whileStmt->set_condition( newExpr ); 190 Visitor::visit( whileStmt ); 191 } 192 193 void Resolver::visit( ForStmt *forStmt ) { 194 // SymTab::Indexer::visit( forStmt ); 195 Expression *newExpr; 196 // for statements introduce a level of scope 197 enterScope(); 198 maybeAccept( forStmt->get_initialization(), *this ); 199 if ( forStmt->get_condition() ) { 200 newExpr = findSingleExpression( forStmt->get_condition(), *this ); 201 delete forStmt->get_condition(); 202 forStmt->set_condition( newExpr ); 203 } // if 204 205 if ( forStmt->get_increment() ) { 206 newExpr = findVoidExpression( forStmt->get_increment(), *this ); 207 delete forStmt->get_increment(); 208 forStmt->set_increment( newExpr ); 209 } // if 210 211 maybeAccept( forStmt->get_condition(), *this ); 212 maybeAccept( forStmt->get_increment(), *this ); 213 maybeAccept( forStmt->get_body(), *this ); 214 leaveScope(); 215 } 216 217 template< typename SwitchClass > 218 void handleSwitchStmt( SwitchClass *switchStmt, SymTab::Indexer &visitor ) { 219 Expression *newExpr; 220 newExpr = findIntegralExpression( switchStmt->get_condition(), visitor ); 221 delete switchStmt->get_condition(); 222 switchStmt->set_condition( newExpr ); 223 224 visitor.Visitor::visit( switchStmt ); 225 } 226 227 void Resolver::visit( SwitchStmt *switchStmt ) { 228 handleSwitchStmt( switchStmt, *this ); 229 } 230 231 void Resolver::visit( ChooseStmt *switchStmt ) { 232 handleSwitchStmt( switchStmt, *this ); 233 } 234 235 void Resolver::visit( CaseStmt *caseStmt ) { 236 Visitor::visit( caseStmt ); 237 } 238 239 void Resolver::visit( ReturnStmt *returnStmt ) { 240 if ( returnStmt->get_expr() ) { 241 CastExpr *castExpr = new CastExpr( returnStmt->get_expr() ); 242 cloneAll( functionReturn, castExpr->get_results() ); 243 Expression *newExpr = findSingleExpression( castExpr, *this ); 244 delete castExpr; 245 returnStmt->set_expr( newExpr ); 246 } // if 247 } 248 249 void Resolver::visit( SingleInit *singleInit ) { 250 if ( singleInit->get_value() ) { 251 #if 0 252 if (NameExpr * ne = dynamic_cast<NameExpr*>(singleInit->get_value())) { 253 string n = ne->get_name(); 254 if (n == "0") { 255 initContext = new BasicType(Type::Qualifiers(), 256 BasicType::SignedInt); 257 } else { 258 DeclarationWithType * decl = lookupId(n); 259 initContext = decl->get_type(); 260 } 261 } else if (ConstantExpr * e = 262 dynamic_cast<ConstantExpr*>(singleInit->get_value())) { 263 Constant *c = e->get_constant(); 264 initContext = c->get_type(); 265 } else { 266 assert(0); 267 } 268 #endif 269 CastExpr *castExpr = new CastExpr( singleInit->get_value(), initContext->clone() ); 270 Expression *newExpr = findSingleExpression( castExpr, *this ); 271 delete castExpr; 272 singleInit->set_value( newExpr ); 273 } // if 182 SymTab::Indexer::visit( functionDecl ); 183 functionReturn = oldFunctionReturn; 184 } 185 186 void Resolver::visit( ExprStmt *exprStmt ) { 187 if ( exprStmt->get_expr() ) { 188 Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this ); 189 delete exprStmt->get_expr(); 190 exprStmt->set_expr( newExpr ); 191 } // if 192 } 193 194 void Resolver::visit( IfStmt *ifStmt ) { 195 Expression *newExpr = findSingleExpression( ifStmt->get_condition(), *this ); 196 delete ifStmt->get_condition(); 197 ifStmt->set_condition( newExpr ); 198 Visitor::visit( ifStmt ); 199 } 200 201 void Resolver::visit( WhileStmt *whileStmt ) { 202 Expression *newExpr = findSingleExpression( whileStmt->get_condition(), *this ); 203 delete whileStmt->get_condition(); 204 whileStmt->set_condition( newExpr ); 205 Visitor::visit( whileStmt ); 206 } 207 208 void Resolver::visit( ForStmt *forStmt ) { 209 // SymTab::Indexer::visit( forStmt ); 210 Expression *newExpr; 211 // for statements introduce a level of scope 212 enterScope(); 213 maybeAccept( forStmt->get_initialization(), *this ); 214 if ( forStmt->get_condition() ) { 215 newExpr = findSingleExpression( forStmt->get_condition(), *this ); 216 delete forStmt->get_condition(); 217 forStmt->set_condition( newExpr ); 218 } // if 219 220 if ( forStmt->get_increment() ) { 221 newExpr = findVoidExpression( forStmt->get_increment(), *this ); 222 delete forStmt->get_increment(); 223 forStmt->set_increment( newExpr ); 224 } // if 225 226 maybeAccept( forStmt->get_condition(), *this ); 227 maybeAccept( forStmt->get_increment(), *this ); 228 maybeAccept( forStmt->get_body(), *this ); 229 leaveScope(); 230 } 231 232 template< typename SwitchClass > 233 void handleSwitchStmt( SwitchClass *switchStmt, SymTab::Indexer &visitor ) { 234 Expression *newExpr; 235 newExpr = findIntegralExpression( switchStmt->get_condition(), visitor ); 236 delete switchStmt->get_condition(); 237 switchStmt->set_condition( newExpr ); 238 239 visitor.Visitor::visit( switchStmt ); 240 } 241 242 void Resolver::visit( SwitchStmt *switchStmt ) { 243 handleSwitchStmt( switchStmt, *this ); 244 } 245 246 void Resolver::visit( ChooseStmt *switchStmt ) { 247 handleSwitchStmt( switchStmt, *this ); 248 } 249 250 void Resolver::visit( CaseStmt *caseStmt ) { 251 Visitor::visit( caseStmt ); 252 } 253 254 void Resolver::visit( ReturnStmt *returnStmt ) { 255 if ( returnStmt->get_expr() ) { 256 CastExpr *castExpr = new CastExpr( returnStmt->get_expr() ); 257 cloneAll( functionReturn, castExpr->get_results() ); 258 Expression *newExpr = findSingleExpression( castExpr, *this ); 259 delete castExpr; 260 returnStmt->set_expr( newExpr ); 261 } // if 262 } 263 264 void Resolver::visit( SingleInit *singleInit ) { 265 if ( singleInit->get_value() ) { 266 #if 0 267 if (NameExpr * ne = dynamic_cast<NameExpr*>(singleInit->get_value())) { 268 string n = ne->get_name(); 269 if (n == "0") { 270 initContext = new BasicType(Type::Qualifiers(), 271 BasicType::SignedInt); 272 } else { 273 DeclarationWithType * decl = lookupId(n); 274 initContext = decl->get_type(); 275 } 276 } else if (ConstantExpr * e = 277 dynamic_cast<ConstantExpr*>(singleInit->get_value())) { 278 Constant *c = e->get_constant(); 279 initContext = c->get_type(); 280 } else { 281 assert(0); 282 } 283 #endif 284 CastExpr *castExpr = new CastExpr( singleInit->get_value(), initContext->clone() ); 285 Expression *newExpr = findSingleExpression( castExpr, *this ); 286 delete castExpr; 287 singleInit->set_value( newExpr ); 288 } // if 274 289 // singleInit->get_value()->accept( *this ); 275 276 277 278 Visitor::visit(listInit);279 #if 0 280 if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) {281 282 283 initContext = at->get_base();284 (*iter)->accept( *this );285 286 } else if ( StructInstType *st = dynamic_cast<StructInstType*>(initContext) ) {287 288 289 290 291 if ( (*iter2)->get_designators().empty() ) {292 293 294 295 296 } else {297 298 299 300 301 NameExpr *key = dynamic_cast<NameExpr *>( *iter3 );302 assert( key );303 for ( ; iter1 != st->get_members().end(); ++iter1 ) {304 305 (*iter1)->print( cout );306 cout << key->get_name() << endl;307 ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );308 assert( fred );309 StructInstType *mary = dynamic_cast<StructInstType*>( fred->get_type() );310 assert( mary );311 st = mary->get_baseStruct();312 iter1 = st->get_members().begin();313 break;314 315 } // for316 317 318 319 320 321 } // if322 323 } else if ( UnionInstType *st = dynamic_cast<UnionInstType*>(initContext) ) {324 325 326 327 } // if328 #endif 329 290 } 291 292 void Resolver::visit( ListInit *listInit ) { 293 Visitor::visit(listInit); 294 #if 0 295 if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) { 296 std::list<Initializer *>::iterator iter( listInit->begin_initializers() ); 297 for ( ; iter != listInit->end_initializers(); ++iter ) { 298 initContext = at->get_base(); 299 (*iter)->accept( *this ); 300 } // for 301 } else if ( StructInstType *st = dynamic_cast<StructInstType*>(initContext) ) { 302 StructDecl *baseStruct = st->get_baseStruct(); 303 std::list<Declaration *>::iterator iter1( baseStruct->get_members().begin() ); 304 std::list<Initializer *>::iterator iter2( listInit->begin_initializers() ); 305 for ( ; iter1 != baseStruct->get_members().end() && iter2 != listInit->end_initializers(); ++iter2 ) { 306 if ( (*iter2)->get_designators().empty() ) { 307 DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *iter1 ); 308 initContext = dt->get_type(); 309 (*iter2)->accept( *this ); 310 ++iter1; 311 } else { 312 StructDecl *st = baseStruct; 313 iter1 = st->get_members().begin(); 314 std::list<Expression *>::iterator iter3( (*iter2)->get_designators().begin() ); 315 for ( ; iter3 != (*iter2)->get_designators().end(); ++iter3 ) { 316 NameExpr *key = dynamic_cast<NameExpr *>( *iter3 ); 317 assert( key ); 318 for ( ; iter1 != st->get_members().end(); ++iter1 ) { 319 if ( key->get_name() == (*iter1)->get_name() ) { 320 (*iter1)->print( cout ); 321 cout << key->get_name() << endl; 322 ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 ); 323 assert( fred ); 324 StructInstType *mary = dynamic_cast<StructInstType*>( fred->get_type() ); 325 assert( mary ); 326 st = mary->get_baseStruct(); 327 iter1 = st->get_members().begin(); 328 break; 329 } // if 330 } // for 331 } // for 332 ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 ); 333 assert( fred ); 334 initContext = fred->get_type(); 335 (*listInit->begin_initializers())->accept( *this ); 336 } // if 337 } // for 338 } else if ( UnionInstType *st = dynamic_cast<UnionInstType*>(initContext) ) { 339 DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *st->get_baseUnion()->get_members().begin() ); 340 initContext = dt->get_type(); 341 (*listInit->begin_initializers())->accept( *this ); 342 } // if 343 #endif 344 } 330 345 } // namespace ResolvExpr 346 347 // Local Variables: // 348 // tab-width: 4 // 349 // mode: c++ // 350 // compile-command: "make install" // 351 // End: //
Note: See TracChangeset
for help on using the changeset viewer.