Ignore:
Timestamp:
May 17, 2015, 1:19:35 PM (9 years ago)
Author:
Peter A. Buhr <pabuhr@…>
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
Message:

licencing: second groups of files

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
    116#include "Resolver.h"
    217#include "AlternativeFinder.h"
    … …  
    1530
    1631namespace 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 );
    8465                } // 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() );
    115181                } // 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
    274289//      singleInit->get_value()->accept( *this );
    275     }
    276 
    277     void Resolver::visit( ListInit *listInit ) {
    278         Visitor::visit(listInit);
    279 #if 0
    280         if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) {
    281             std::list<Initializer *>::iterator iter( listInit->begin_initializers() );
    282             for ( ; iter != listInit->end_initializers(); ++iter ) {
    283                 initContext = at->get_base();
    284                 (*iter)->accept( *this );
    285             } // for
    286         } else if ( StructInstType *st = dynamic_cast<StructInstType*>(initContext) ) {
    287             StructDecl *baseStruct = st->get_baseStruct();
    288             std::list<Declaration *>::iterator iter1( baseStruct->get_members().begin() );
    289             std::list<Initializer *>::iterator iter2( listInit->begin_initializers() );
    290             for ( ; iter1 != baseStruct->get_members().end() && iter2 != listInit->end_initializers(); ++iter2 ) {
    291                 if ( (*iter2)->get_designators().empty() ) {
    292                     DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *iter1 );
    293                     initContext = dt->get_type();
    294                     (*iter2)->accept( *this );
    295                     ++iter1;
    296                 } else {
    297                     StructDecl *st = baseStruct;
    298                     iter1 = st->get_members().begin();
    299                     std::list<Expression *>::iterator iter3( (*iter2)->get_designators().begin() );
    300                     for ( ; iter3 != (*iter2)->get_designators().end(); ++iter3 ) {
    301                         NameExpr *key = dynamic_cast<NameExpr *>( *iter3 );
    302                         assert( key );
    303                         for ( ; iter1 != st->get_members().end(); ++iter1 ) {
    304                             if ( key->get_name() == (*iter1)->get_name() ) {
    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                             } // if
    315                         }  // for
    316                     } // for
    317                     ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
    318                     assert( fred );
    319                     initContext = fred->get_type();
    320                     (*listInit->begin_initializers())->accept( *this );
    321                 } // if
    322             } // for
    323         } else if ( UnionInstType *st = dynamic_cast<UnionInstType*>(initContext) ) {
    324             DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *st->get_baseUnion()->get_members().begin() );
    325             initContext = dt->get_type();
    326             (*listInit->begin_initializers())->accept( *this );
    327         } // if
    328 #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        }
    330345} // 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.