Changeset 6c3744e


Ignore:
Timestamp:
Jan 19, 2015, 6:29:10 PM (7 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, 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, resolv-new, string, with_gc
Children:
f7f6785
Parents:
0b8cd72
Message:

add list initializer, formatting changes

Files:
2 deleted
13 edited

Legend:

Unmodified
Added
Removed
  • driver/cc1.cc

    r0b8cd72 r6c3744e  
    88// Created On       : Fri Aug 26 14:23:51 2005
    99// Last Modified By : Peter A. Buhr
    10 // Last Modified On : Sun Dec  7 22:21:33 2014
    11 // Update Count     : 14
     10// Last Modified On : Sat Jan 10 14:16:06 2015
     11// Update Count     : 15
    1212//
    13 // This  library is free  software; you  can redistribute  it and/or  modify it
    14 // under the terms of the GNU Lesser General Public License as published by the
    15 // Free Software  Foundation; either  version 2.1 of  the License, or  (at your
    16 // option) any later version.
    17 //
    18 // This library is distributed in the  hope that it will be useful, but WITHOUT
    19 // ANY  WARRANTY;  without even  the  implied  warranty  of MERCHANTABILITY  or
    20 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
    21 // for more details.
    22 //
    23 // You should  have received a  copy of the  GNU Lesser General  Public License
    24 // along  with this library.
    25 //
    2613
    2714
  • translator/CodeGen/CodeGenerator2.cc

    r0b8cd72 r6c3744e  
    477477
    478478        // horrible, horrible hack
    479         if ( dynamic_cast<BranchStmt *>( stmts.back()) != 0 ) {
     479        if ( dynamic_cast<BranchStmt *>( stmts.back() ) != 0 ) {
    480480            lastBreak = true;
    481481            stmts.pop_back();
     
    485485            Statement *st = switchStmt->get_branches().back();
    486486            before << CodeGenerator2::printLabels( st->get_labels());
    487             st->accept(*this );
     487            st->accept( *this );
    488488        } // if
    489489     
     
    524524                if ( branchStmt->get_computedTarget() != 0 ) {
    525525                    before << "goto *";
    526                     branchStmt->get_computedTarget()->accept(*this );
     526                    branchStmt->get_computedTarget()->accept( *this );
    527527                } // if
    528528            } // if
  • translator/ControlStruct/LabelFixer.cc

    r0b8cd72 r6c3744e  
    2424    }
    2525
    26     void LabelFixer::visit(FunctionDecl *functionDecl) {
     26    void LabelFixer::visit( FunctionDecl *functionDecl ) {
    2727        if ( functionDecl->get_statements() != 0 )
    2828            functionDecl->get_statements()->accept( *this );
     
    3232    }
    3333
    34     void LabelFixer::visit(Statement *stmt ) {
     34    void LabelFixer::visit( Statement *stmt ) {
    3535        std::list< Label > &labels = stmt->get_labels();
    3636
     
    4242    }
    4343
    44     void LabelFixer::visit(BranchStmt *branchStmt) {
     44    void LabelFixer::visit( BranchStmt *branchStmt ) {
    4545        visit ( ( Statement * )branchStmt );  // the labels this statement might have
    4646
     
    5050        } //else       /* computed goto or normal exit-loop statements */
    5151    }
    52 
    5352
    5453    Label LabelFixer::setLabelsDef( std::list< Label > &llabel, Statement *definition ) {
     
    6160                { used = true; labelTable[ *i ] = entry; } // undefined and unused
    6261            else
    63                 if( labelTable[ *i ]->defined() )
    64                     throw SemanticError("Duplicate definition of label: " + *i );
     62                if ( labelTable[ *i ]->defined() )
     63                    throw SemanticError( "Duplicate definition of label: " + *i );
    6564                else
    6665                    labelTable[ *i ]->set_definition( definition );
     
    8281    }
    8382
    84     std::map < Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticError ) {
    85         std::map < Statement *, Entry * > def_us;
     83    std::map<Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticError ) {
     84        std::map< Statement *, Entry * > def_us;
    8685
    87         for ( std::map < Label, Entry *>::iterator i = labelTable.begin(); i != labelTable.end(); i++ ) {
     86        for ( std::map< Label, Entry *>::iterator i = labelTable.begin(); i != labelTable.end(); i++ ) {
    8887            Entry *e = i->second;
    8988
     
    9190                def_us[ e->get_definition() ] = e;
    9291            else
    93                 if(e->used())
     92                if ( e->used() )
    9493                    def_us[ e->get_definition() ]->add_uses( e->get_uses() );
    9594        }
    9695
    9796        // get rid of labelTable
    98         for ( std::map < Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); i++ ) {
     97        for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); i++ ) {
    9998            Statement *to = (*i).first;
    100             std::list < Statement *> &from = (*i).second->get_uses();
     99            std::list< Statement *> &from = (*i).second->get_uses();
    101100            Label finalLabel = generator->newLabel();
    102101            (*i).second->set_label( finalLabel );
     
    114113
    115114            for ( std::list< Statement *>::iterator j = from.begin(); j != from.end(); j++ ) {
    116                 BranchStmt *jumpTo = dynamic_cast < BranchStmt * > ( *j );
     115                BranchStmt *jumpTo = dynamic_cast< BranchStmt * > ( *j );
    117116                assert( jumpTo != 0 );
    118117                jumpTo->set_target( finalLabel );
     
    121120
    122121        // reverse table
    123         std::map < Label, Statement * > *ret = new std::map < Label, Statement * >();
    124         for (std::map < Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); i++ )
     122        std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
     123        for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); i++ )
    125124            (*ret)[ (*i).second->get_label() ] = (*i).first;
    126125
  • translator/ControlStruct/MLEMutator.cc

    r0b8cd72 r6c3744e  
    1212    }
    1313
    14     CompoundStmt* MLEMutator::mutate(CompoundStmt *cmpndStmt) {
     14    CompoundStmt* MLEMutator::mutate( CompoundStmt *cmpndStmt ) {
    1515        bool labeledBlock = false;
    1616        if ( !((cmpndStmt->get_labels()).empty()) ) {
     
    2727                if ( next == kids.end() ) {
    2828                    std::list<Label> ls; ls.push_back( get_breakLabel() );
    29                     kids.push_back( new NullStmt(ls) );
     29                    kids.push_back( new NullStmt( ls ) );
    3030                } else
    3131                    (*next)->get_labels().push_back( get_breakLabel() );
     
    8888        std::list< Entry >::iterator check;
    8989        if ( ( check = std::find( enclosingLoops.begin(), enclosingLoops.end(), (*targetTable)[branchStmt->get_target()] ) ) == enclosingLoops.end() )
    90             // not in loop, checking if in switch/choose
     90            // not in loop, checking if in block
    9191            if ( (check = std::find( enclosingBlocks.begin(), enclosingBlocks.end(), (*targetTable)[branchStmt->get_target()] )) == enclosingBlocks.end() )
    9292                // neither in loop nor in block, checking if in switch/choose
     
    9595
    9696        if ( enclosingLoops.back() == (*check) )
    97             return branchStmt;                      // exit the innermost loop (labels not necessary)
     97            return branchStmt;                          // exit the innermost loop (labels unnecessary)
    9898
    9999        Label newLabel;
     
    102102            if ( check->get_breakExit() != "" )
    103103                newLabel = check->get_breakExit();
    104             else { newLabel = generator->newLabel(); check->set_breakExit( newLabel ); }
     104            else {
     105                newLabel = generator->newLabel();
     106                check->set_breakExit( newLabel );
     107            } // if
    105108            break;
    106109          case BranchStmt::Continue:
    107110            if ( check->get_contExit() != "" )
    108111                newLabel = check->get_contExit();
    109             else { newLabel = generator->newLabel(); check->set_contExit( newLabel ); }
     112            else {
     113                newLabel = generator->newLabel();
     114                check->set_contExit( newLabel );
     115            } // if
    110116            break;
    111117          default:
    112             // shouldn't be here
    113             return 0;
     118            return 0;                                   // shouldn't be here
    114119        } // switch
    115120
    116         return new BranchStmt(std::list<Label>(), newLabel, BranchStmt::Goto );
     121        return new BranchStmt( std::list<Label>(), newLabel, BranchStmt::Goto );
    117122    }
    118123
    119124
    120     Statement *MLEMutator::mutate(SwitchStmt *switchStmt) {
     125    Statement *MLEMutator::mutate( SwitchStmt *switchStmt ) {
    121126        Label brkLabel = generator->newLabel();
    122127        enclosingSwitches.push_back( Entry(switchStmt, "", brkLabel) );
     
    131136    }
    132137
    133     Statement *MLEMutator::mutate(ChooseStmt *switchStmt) {
     138    Statement *MLEMutator::mutate( ChooseStmt *switchStmt ) {
    134139        Label brkLabel = generator->newLabel();
    135140        enclosingSwitches.push_back( Entry(switchStmt,"", brkLabel) );
  • translator/ControlStruct/MLEMutator.h

    r0b8cd72 r6c3744e  
    1515        class Entry;
    1616      public:
    17         MLEMutator( std::map <Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
     17        MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
    1818        ~MLEMutator();
    1919
     
    5656        };
    5757
    58         std::map <Label, Statement *> *targetTable;
    59         std::list < Entry > enclosingBlocks,enclosingLoops,enclosingSwitches;
     58        std::map< Label, Statement * > *targetTable;
     59        std::list< Entry > enclosingBlocks, enclosingLoops, enclosingSwitches;
    6060        Label breakLabel;
    6161        LabelGenerator *generator;
  • translator/GenPoly/Box.cc

    r0b8cd72 r6c3744e  
    3333
    3434namespace GenPoly {
    35 
    36 namespace {
    37 
    38 const std::list<Label> noLabels;
    39 
    40 class Pass1 : public PolyMutator
    41 {
    42 public:
    43   Pass1();
    44   virtual Expression *mutate( ApplicationExpr *appExpr );
    45   virtual Expression *mutate( AddressExpr *addrExpr );
    46   virtual Expression *mutate( UntypedExpr *expr );
    47   virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
    48   virtual TypeDecl* mutate( TypeDecl *typeDecl );
    49   virtual Expression *mutate( CommaExpr *commaExpr );
    50   virtual Expression *mutate( ConditionalExpr *condExpr );
    51   virtual Statement* mutate(ReturnStmt *catchStmt);
    52   virtual Type* mutate( PointerType *pointerType );
    53   virtual Type* mutate( FunctionType *pointerType );
    54  
    55   virtual void doEndScope();
    56  
    57 private:
    58   void passTypeVars( ApplicationExpr* appExpr, std::list< Expression* >::iterator &arg, const TyVarMap &exprTyVars );
    59   Expression* addRetParam( ApplicationExpr* appExpr, FunctionType *function, Type *retType, std::list< Expression* >::iterator &arg );
    60   Expression* addPolyRetParam( ApplicationExpr* appExpr, FunctionType *function, std::string typeName, std::list< Expression* >::iterator &arg );
    61   Expression* applyAdapter( ApplicationExpr* appExpr, FunctionType *function, std::list< Expression* >::iterator &arg, const TyVarMap &exprTyVars );
    62   void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
    63   void boxParams( ApplicationExpr* appExpr, FunctionType *function, std::list< Expression* >::iterator &arg, const TyVarMap &exprTyVars );
    64   void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression* >::iterator &arg, const TyVarMap &tyVars );
    65   void findAssignOps( const std::list< TypeDecl* > &forall );
    66   void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
    67   FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
    68   Expression *handleIntrinsics( ApplicationExpr *appExpr );
    69   ObjectDecl *makeTemporary( Type *type );
    70  
    71   std::map< std::string, DeclarationWithType* > assignOps;
    72   std::map< std::string, FunctionDecl* > adapters;
    73   DeclarationWithType* retval;
    74   bool useRetval;
    75   UniqueName tempNamer;
    76 };
    77 
    78 class Pass2 : public PolyMutator
    79 {
    80 public:
    81   Pass2();
    82   template< typename DeclClass >
    83   DeclClass* handleDecl( DeclClass *decl, Type *type );
    84   virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
    85   virtual ObjectDecl* mutate( ObjectDecl *objectDecl );
    86   virtual TypeDecl* mutate( TypeDecl *typeDecl );
    87   virtual TypedefDecl* mutate( TypedefDecl *typedefDecl );
    88   virtual Type* mutate( PointerType *pointerType );
    89   virtual Type* mutate( FunctionType *funcType );
    90 
    91 private:
    92   void addAdapters( FunctionType *functionType );
    93  
    94   std::map< UniqueId, std::string > adapterName;
    95 };
    96 
    97 class Pass3 : public PolyMutator
    98 {
    99 public:
    100   template< typename DeclClass >
    101   DeclClass* handleDecl( DeclClass *decl, Type *type );
    102   virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
    103   virtual ObjectDecl* mutate( ObjectDecl *objectDecl );
    104   virtual TypedefDecl* mutate( TypedefDecl *objectDecl );
    105   virtual TypeDecl* mutate( TypeDecl *objectDecl );
    106   virtual Statement* mutate( DeclStmt *declStmt );
    107   virtual Type* mutate( PointerType *pointerType );
    108   virtual Type* mutate( FunctionType *funcType );
    109 
    110 private:
    111 };
    112 
    113 } // anonymous namespace
    114 
    115 void
    116 printAllNotBuiltin( const std::list< Declaration* >& translationUnit, std::ostream &os )
    117 {
    118   for( std::list< Declaration* >::const_iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
    119     if( !LinkageSpec::isBuiltin( (*i)->get_linkage() ) ) {
    120       (*i)->print( os );
    121       os << std::endl;
     35    namespace {
     36        const std::list<Label> noLabels;
     37
     38        class Pass1 : public PolyMutator {
     39          public:
     40            Pass1();
     41            virtual Expression *mutate( ApplicationExpr *appExpr );
     42            virtual Expression *mutate( AddressExpr *addrExpr );
     43            virtual Expression *mutate( UntypedExpr *expr );
     44            virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
     45            virtual TypeDecl *mutate( TypeDecl *typeDecl );
     46            virtual Expression *mutate( CommaExpr *commaExpr );
     47            virtual Expression *mutate( ConditionalExpr *condExpr );
     48            virtual Statement *mutate(ReturnStmt *catchStmt);
     49            virtual Type *mutate( PointerType *pointerType );
     50            virtual Type *mutate( FunctionType *pointerType );
     51 
     52            virtual void doEndScope();
     53          private:
     54            void passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
     55            Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
     56            Expression *addPolyRetParam( ApplicationExpr *appExpr, FunctionType *function, std::string typeName, std::list< Expression *>::iterator &arg );
     57            Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
     58            void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
     59            void boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
     60            void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars );
     61            void findAssignOps( const std::list< TypeDecl *> &forall );
     62            void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
     63            FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
     64            Expression *handleIntrinsics( ApplicationExpr *appExpr );
     65            ObjectDecl *makeTemporary( Type *type );
     66 
     67            std::map< std::string, DeclarationWithType *> assignOps;
     68            std::map< std::string, FunctionDecl *> adapters;
     69            DeclarationWithType *retval;
     70            bool useRetval;
     71            UniqueName tempNamer;
     72        };
     73
     74        class Pass2 : public PolyMutator {
     75          public:
     76            Pass2();
     77            template< typename DeclClass >
     78            DeclClass *handleDecl( DeclClass *decl, Type *type );
     79            virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
     80            virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
     81            virtual TypeDecl *mutate( TypeDecl *typeDecl );
     82            virtual TypedefDecl *mutate( TypedefDecl *typedefDecl );
     83            virtual Type *mutate( PointerType *pointerType );
     84            virtual Type *mutate( FunctionType *funcType );
     85          private:
     86            void addAdapters( FunctionType *functionType );
     87 
     88            std::map< UniqueId, std::string > adapterName;
     89        };
     90
     91        class Pass3 : public PolyMutator {
     92          public:
     93            template< typename DeclClass >
     94            DeclClass *handleDecl( DeclClass *decl, Type *type );
     95            virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
     96            virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
     97            virtual TypedefDecl *mutate( TypedefDecl *objectDecl );
     98            virtual TypeDecl *mutate( TypeDecl *objectDecl );
     99            virtual Statement *mutate( DeclStmt *declStmt );
     100            virtual Type *mutate( PointerType *pointerType );
     101            virtual Type *mutate( FunctionType *funcType );
     102          private:
     103        };
     104
     105    } // anonymous namespace
     106
     107    void printAllNotBuiltin( const std::list< Declaration *>& translationUnit, std::ostream &os ) {
     108        for ( std::list< Declaration *>::const_iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
     109            if ( !LinkageSpec::isBuiltin( (*i)->get_linkage() ) ) {
     110                (*i)->print( os );
     111                os << std::endl;
     112            } // if
     113        } // for
    122114    }
    123   }
    124 }
    125 
    126 void
    127 box( std::list< Declaration* >& translationUnit )
    128 {
    129   Pass1 pass1;
    130   Pass2 pass2;
    131   Pass3 pass3;
    132   mutateAll( translationUnit, pass1 );
    133   mutateAll( translationUnit, pass2 );
    134   mutateAll( translationUnit, pass3 );
    135 }
     115
     116    void box( std::list< Declaration *>& translationUnit ) {
     117        Pass1 pass1;
     118        Pass2 pass2;
     119        Pass3 pass3;
     120        mutateAll( translationUnit, pass1 );
     121        mutateAll( translationUnit, pass2 );
     122        mutateAll( translationUnit, pass3 );
     123    }
    136124
    137125////////////////////////////////////////// Pass1 ////////////////////////////////////////////////////
    138126
    139 namespace {
    140 
    141 bool
    142 isPolyRet( FunctionType *function, std::string &name, const TyVarMap &otherTyVars )
    143 {
    144   bool doTransform = false;
    145   if( !function->get_returnVals().empty() ) {
    146     if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( function->get_returnVals().front()->get_type() ) ) {
     127    namespace {
     128        bool isPolyRet( FunctionType *function, std::string &name, const TyVarMap &otherTyVars ) {
     129            bool doTransform = false;
     130            if ( !function->get_returnVals().empty() ) {
     131                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( function->get_returnVals().front()->get_type() ) ) {
    147132   
    148       // figure out if the return type is specified by a type parameter
    149       for( std::list< TypeDecl* >::const_iterator tyVar = function->get_forall().begin(); tyVar != function->get_forall().end(); ++tyVar ) {
    150         if( (*tyVar)->get_name() == typeInst->get_name() ) {
    151           doTransform = true;
    152           name = typeInst->get_name();
    153           break;
    154         }
    155       }
    156       if( !doTransform && otherTyVars.find( typeInst->get_name() ) != otherTyVars.end() ) {
    157         doTransform = true;
    158       }
    159     }
    160   }
    161   return doTransform;
    162 }
    163 
    164 bool
    165 isPolyRet( FunctionType *function, std::string &name )
    166 {
    167   TyVarMap dummyTyVars;
    168   return isPolyRet( function, name, dummyTyVars );
    169 }
    170 
    171 Pass1::Pass1()
    172   : useRetval( false ), tempNamer( "_temp" )
    173 {
    174 }
    175 
    176 bool
    177 checkAssignment( DeclarationWithType *decl, std::string &name )
    178 {
    179   if( decl->get_name() == "?=?" ) {
    180     if( PointerType *ptrType = dynamic_cast< PointerType* >( decl->get_type() ) ) {
    181       if( FunctionType *funType = dynamic_cast< FunctionType* >( ptrType->get_base() ) ) {
    182         if( funType->get_parameters().size() == 2 ) {
    183           if( PointerType *pointer = dynamic_cast< PointerType* >( funType->get_parameters().front()->get_type() ) ) {
    184             if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) {
    185               name = typeInst->get_name();
    186               return true;
    187             }
    188           }
    189         }
    190       }
    191     }
    192   }
    193   return false;
    194 }
    195 
    196 void
    197 Pass1::findAssignOps( const std::list< TypeDecl* > &forall )
    198 {
    199   assignOps.clear();
    200   for( std::list< TypeDecl* >::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
    201     for( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
    202       std::string typeName;
    203       if( checkAssignment( *assert, typeName ) ) {
    204         assignOps[ typeName ] = *assert;
    205       }
    206     }
    207   }
    208 }
    209 
    210 DeclarationWithType*
    211 Pass1::mutate( FunctionDecl *functionDecl )
    212 {
    213   if( functionDecl->get_statements() ) {
    214     TyVarMap oldtyVars = scopeTyVars;
    215     DeclarationWithType *oldRetval = retval;
    216     bool oldUseRetval = useRetval;
     133                    // figure out if the return type is specified by a type parameter
     134                    for ( std::list< TypeDecl *>::const_iterator tyVar = function->get_forall().begin(); tyVar != function->get_forall().end(); ++tyVar ) {
     135                        if ( (*tyVar)->get_name() == typeInst->get_name() ) {
     136                            doTransform = true;
     137                            name = typeInst->get_name();
     138                            break;
     139                        } // if
     140                    } // for
     141                    if ( !doTransform && otherTyVars.find( typeInst->get_name() ) != otherTyVars.end() ) {
     142                        doTransform = true;
     143                    } // if
     144                } // if
     145            } // if
     146            return doTransform;
     147        }
     148
     149        bool isPolyRet( FunctionType *function, std::string &name ) {
     150            TyVarMap dummyTyVars;
     151            return isPolyRet( function, name, dummyTyVars );
     152        }
     153
     154        Pass1::Pass1()
     155            : useRetval( false ), tempNamer( "_temp" ) {
     156        }
     157
     158        bool checkAssignment( DeclarationWithType *decl, std::string &name ) {
     159            if ( decl->get_name() == "?=?" ) {
     160                if ( PointerType *ptrType = dynamic_cast< PointerType *>( decl->get_type() ) ) {
     161                    if ( FunctionType *funType = dynamic_cast< FunctionType *>( ptrType->get_base() ) ) {
     162                        if ( funType->get_parameters().size() == 2 ) {
     163                            if ( PointerType *pointer = dynamic_cast< PointerType *>( funType->get_parameters().front()->get_type() ) ) {
     164                                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( pointer->get_base() ) ) {
     165                                    name = typeInst->get_name();
     166                                    return true;
     167                                } // if
     168                            } // if
     169                        } // if
     170                    } // if
     171                } // if
     172            } // if
     173            return false;
     174        }
     175
     176        void Pass1::findAssignOps( const std::list< TypeDecl *> &forall ) {
     177            assignOps.clear();
     178            for ( std::list< TypeDecl *>::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
     179                for ( std::list< DeclarationWithType *>::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
     180                    std::string typeName;
     181                    if ( checkAssignment( *assert, typeName ) ) {
     182                        assignOps[ typeName ] = *assert;
     183                    } // if
     184                } // for
     185            } // for
     186        }
     187
     188        DeclarationWithType *
     189        Pass1::mutate( FunctionDecl *functionDecl ) {
     190            if ( functionDecl->get_statements() ) {
     191                TyVarMap oldtyVars = scopeTyVars;
     192                DeclarationWithType *oldRetval = retval;
     193                bool oldUseRetval = useRetval;
    217194   
    218     retval = 0;
    219     std::string typeName;
    220     if( isPolyRet( functionDecl->get_functionType(), typeName ) && functionDecl->get_linkage() == LinkageSpec::Cforall ) {
    221       retval = functionDecl->get_functionType()->get_returnVals().front();
    222  
    223       // give names to unnamed return values
    224       if( retval->get_name() == "" ) {
    225         retval->set_name( "_retparm" );
    226         retval->set_linkage( LinkageSpec::C );
    227       }
    228     }
     195                retval = 0;
     196                std::string typeName;
     197                if ( isPolyRet( functionDecl->get_functionType(), typeName ) && functionDecl->get_linkage() == LinkageSpec::Cforall ) {
     198                    retval = functionDecl->get_functionType()->get_returnVals().front();
     199 
     200                    // give names to unnamed return values
     201                    if ( retval->get_name() == "" ) {
     202                        retval->set_name( "_retparm" );
     203                        retval->set_linkage( LinkageSpec::C );
     204                    } // if
     205                } // if
    229206   
    230     scopeTyVars.clear();
     207                scopeTyVars.clear();
    231208///     std::cerr << "clear\n";
    232     makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
    233     findAssignOps( functionDecl->get_functionType()->get_forall() );
    234     functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
    235  
    236     scopeTyVars = oldtyVars;
     209                makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
     210                findAssignOps( functionDecl->get_functionType()->get_forall() );
     211                functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
     212 
     213                scopeTyVars = oldtyVars;
    237214///     std::cerr << "end FunctionDecl: ";
    238 ///     for( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
     215///     for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
    239216///       std::cerr << i->first << " ";
    240217///     }
    241218///     std::cerr << "\n";
    242     retval = oldRetval;
    243     useRetval = oldUseRetval;
    244     doEndScope();
    245   }
    246   return functionDecl;
    247 }
    248 
    249 TypeDecl*
    250 Pass1::mutate( TypeDecl *typeDecl )
    251 {
     219                retval = oldRetval;
     220                useRetval = oldUseRetval;
     221                doEndScope();
     222            } // if
     223            return functionDecl;
     224        }
     225
     226        TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
    252227///     std::cerr << "add " << typeDecl->get_name() << "\n";
    253   scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
    254   return Mutator::mutate( typeDecl );
    255 }
    256 
    257 Expression *
    258 Pass1::mutate( CommaExpr *commaExpr )
    259 {
    260   bool oldUseRetval = useRetval;
    261   useRetval = false;
    262   commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
    263   useRetval = oldUseRetval;
    264   commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
    265   return commaExpr;
    266 }
    267 
    268 Expression *
    269 Pass1::mutate( ConditionalExpr *condExpr )
    270 {
    271   bool oldUseRetval = useRetval;
    272   useRetval = false;
    273   condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) );
    274   useRetval = oldUseRetval;
    275   condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) );
    276   condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) );
    277   return condExpr;
    278 
    279 }
    280 
    281 void
    282 Pass1::passTypeVars( ApplicationExpr* appExpr, std::list< Expression* >::iterator &arg, const TyVarMap &exprTyVars )
    283 {
    284   for( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
    285     ResolvExpr::EqvClass eqvClass;
    286     assert( env );
    287     if( tyParm->second == TypeDecl::Any ) {
    288       Type *concrete = env->lookup( tyParm->first );
    289       if( concrete ) {
    290         arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
    291         arg++;
    292       } else {
    293         throw SemanticError( "unbound type variable in application ", appExpr );
    294       }
    295     }
    296   }
    297 }
    298 
    299 ObjectDecl*
    300 Pass1::makeTemporary( Type *type )
    301 {
    302   ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, type, 0 );
    303   stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
    304   return newObj;
    305 }
    306 
    307 TypeInstType *
    308 isPolyType( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars )
    309 {
    310   if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
    311     if( env ) {
    312       if( Type *newType = env->lookup( typeInst->get_name() ) ) {
    313         return isPolyType( newType, env, tyVars );
    314       }
    315     }
    316     if( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
    317       return typeInst;
    318     } else {
    319       return 0;
    320     }
    321   } else {
    322     return 0;
    323   }
    324 }
    325 
    326 Expression*
    327 Pass1::addRetParam( ApplicationExpr* appExpr, FunctionType *function, Type *retType, std::list< Expression* >::iterator &arg )
    328 {
    329   if( useRetval ) {
    330     assert( retval );
    331     arg = appExpr->get_args().insert( arg, new VariableExpr( retval ) );
    332     arg++;
    333   } else {
    334     ObjectDecl *newObj = makeTemporary( retType->clone() );
    335     Expression *paramExpr = new VariableExpr( newObj );
    336     if( !isPolyType( newObj->get_type(), env, scopeTyVars ) ) {
    337       paramExpr = new AddressExpr( paramExpr );
    338     }
    339     arg = appExpr->get_args().insert( arg, paramExpr );
    340     arg++;
     228            scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
     229            return Mutator::mutate( typeDecl );
     230        }
     231
     232        Expression *Pass1::mutate( CommaExpr *commaExpr ) {
     233            bool oldUseRetval = useRetval;
     234            useRetval = false;
     235            commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
     236            useRetval = oldUseRetval;
     237            commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
     238            return commaExpr;
     239        }
     240
     241        Expression *Pass1::mutate( ConditionalExpr *condExpr ) {
     242            bool oldUseRetval = useRetval;
     243            useRetval = false;
     244            condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) );
     245            useRetval = oldUseRetval;
     246            condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) );
     247            condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) );
     248            return condExpr;
     249
     250        }
     251
     252        void Pass1::passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
     253            for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
     254                ResolvExpr::EqvClass eqvClass;
     255                assert( env );
     256                if ( tyParm->second == TypeDecl::Any ) {
     257                    Type *concrete = env->lookup( tyParm->first );
     258                    if ( concrete ) {
     259                        arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
     260                        arg++;
     261                    } else {
     262                        throw SemanticError( "unbound type variable in application ", appExpr );
     263                    } // if
     264                } // if
     265            } // for
     266        }
     267
     268        ObjectDecl *Pass1::makeTemporary( Type *type ) {
     269            ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, type, 0 );
     270            stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
     271            return newObj;
     272        }
     273
     274        TypeInstType *isPolyType( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars ) {
     275            if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
     276                if ( env ) {
     277                    if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
     278                        return isPolyType( newType, env, tyVars );
     279                    } // if
     280                } // if
     281                if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
     282                    return typeInst;
     283                } else {
     284                    return 0;
     285                } // if
     286            } else {
     287                return 0;
     288            } // if
     289        }
     290
     291        Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) {
     292            if ( useRetval ) {
     293                assert( retval );
     294                arg = appExpr->get_args().insert( arg, new VariableExpr( retval ) );
     295                arg++;
     296            } else {
     297                ObjectDecl *newObj = makeTemporary( retType->clone() );
     298                Expression *paramExpr = new VariableExpr( newObj );
     299                if ( !isPolyType( newObj->get_type(), env, scopeTyVars ) ) {
     300                    paramExpr = new AddressExpr( paramExpr );
     301                } // if
     302                arg = appExpr->get_args().insert( arg, paramExpr );
     303                arg++;
    341304///     stmtsToAdd.push_back( new ExprStmt( noLabels, appExpr ) );
    342     CommaExpr *commaExpr = new CommaExpr( appExpr, new VariableExpr( newObj ) );
    343     commaExpr->set_env( appExpr->get_env() );
    344     appExpr->set_env( 0 );
    345     return commaExpr;
    346   }
    347   return appExpr;
    348 }
    349 
    350 Expression*
    351 Pass1::addPolyRetParam( ApplicationExpr* appExpr, FunctionType *function, std::string typeName, std::list< Expression* >::iterator &arg )
    352 {
    353   ResolvExpr::EqvClass eqvClass;
    354   assert( env );
    355   Type *concrete = env->lookup( typeName );
    356   if( concrete == 0 ) {
    357     throw SemanticError( "Unbound type variable " + typeName + " in", appExpr );
    358   }
    359   return addRetParam( appExpr, function, concrete, arg );
    360 }
    361 
    362 Expression*
    363 Pass1::applyAdapter( ApplicationExpr* appExpr, FunctionType *function, std::list< Expression* >::iterator &arg, const TyVarMap &tyVars )
    364 {
    365   Expression *ret = appExpr;
    366   if( !function->get_returnVals().empty() && isPolyVal( function->get_returnVals().front()->get_type(), tyVars ) ) {
    367     ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg );
    368   }
    369   appExpr->get_args().push_front( appExpr->get_function() );
    370   appExpr->set_function( new NameExpr( "_adapter" + SymTab::Mangler::mangle( function ) ) );
    371  
    372   return ret;
    373 }
    374 
    375 void
    376 Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars )
    377 {
    378   assert( !arg->get_results().empty() );
    379 ///   if( !dynamic_cast< PointerType* >( arg->get_results().front() ) ) {
    380     TypeInstType *typeInst = dynamic_cast< TypeInstType* >( param );
    381     if( typeInst && exprTyVars.find( typeInst->get_name() ) != exprTyVars.end() ) {
    382       if( arg->get_results().front()->get_isLvalue() ) {
    383         arg = new AddressExpr( arg );
    384       } else {
    385         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, arg->get_results().front()->clone(), 0 );
    386         newObj->get_type()->get_qualifiers() = Type::Qualifiers();
    387         stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
    388         UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
    389         assign->get_args().push_back( new VariableExpr( newObj ) );
    390         assign->get_args().push_back( arg );
    391         stmtsToAdd.push_back( new ExprStmt( noLabels, assign ) );
    392         arg = new AddressExpr( new VariableExpr( newObj ) );
    393       }
    394     }
     305                CommaExpr *commaExpr = new CommaExpr( appExpr, new VariableExpr( newObj ) );
     306                commaExpr->set_env( appExpr->get_env() );
     307                appExpr->set_env( 0 );
     308                return commaExpr;
     309            } // if
     310            return appExpr;
     311        }
     312
     313        Expression *Pass1::addPolyRetParam( ApplicationExpr *appExpr, FunctionType *function, std::string typeName, std::list< Expression *>::iterator &arg ) {
     314            ResolvExpr::EqvClass eqvClass;
     315            assert( env );
     316            Type *concrete = env->lookup( typeName );
     317            if ( concrete == 0 ) {
     318                throw SemanticError( "Unbound type variable " + typeName + " in", appExpr );
     319            } // if
     320            return addRetParam( appExpr, function, concrete, arg );
     321        }
     322
     323        Expression *Pass1::applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
     324            Expression *ret = appExpr;
     325            if ( !function->get_returnVals().empty() && isPolyVal( function->get_returnVals().front()->get_type(), tyVars ) ) {
     326                ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg );
     327            } // if
     328            appExpr->get_args().push_front( appExpr->get_function() );
     329            appExpr->set_function( new NameExpr( "_adapter" + SymTab::Mangler::mangle( function ) ) );
     330 
     331            return ret;
     332        }
     333
     334        void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
     335            assert( !arg->get_results().empty() );
     336///   if ( !dynamic_cast< PointerType *>( arg->get_results().front() ) ) {
     337            TypeInstType *typeInst = dynamic_cast< TypeInstType *>( param );
     338            if ( typeInst && exprTyVars.find( typeInst->get_name() ) != exprTyVars.end() ) {
     339                if ( arg->get_results().front()->get_isLvalue() ) {
     340                    arg = new AddressExpr( arg );
     341                } else {
     342                    ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, arg->get_results().front()->clone(), 0 );
     343                    newObj->get_type()->get_qualifiers() = Type::Qualifiers();
     344                    stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
     345                    UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
     346                    assign->get_args().push_back( new VariableExpr( newObj ) );
     347                    assign->get_args().push_back( arg );
     348                    stmtsToAdd.push_back( new ExprStmt( noLabels, assign ) );
     349                    arg = new AddressExpr( new VariableExpr( newObj ) );
     350                } // if
     351            } // if
    395352///   }
    396 }
    397 
    398 void
    399 addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars )
    400 {
    401   Type *newType = formal->clone();
    402   std::list< FunctionType* > functions;
    403   // instead of functions needing adapters, this really ought to look for
    404   // any function mentioning a polymorphic type
    405   findAndReplaceFunction( newType, functions, tyVars, needsAdapter );
    406   if( !functions.empty() ) {
    407     actual = new CastExpr( actual, newType );
    408   } else {
    409     delete newType;
    410   }
    411 }
    412 
    413 void
    414 Pass1::boxParams( ApplicationExpr* appExpr, FunctionType *function, std::list< Expression* >::iterator &arg, const TyVarMap &exprTyVars )
    415 {
     353        }
     354
     355        void addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars ) {
     356            Type *newType = formal->clone();
     357            std::list< FunctionType *> functions;
     358            // instead of functions needing adapters, this really ought to look for
     359            // any function mentioning a polymorphic type
     360            findAndReplaceFunction( newType, functions, tyVars, needsAdapter );
     361            if ( !functions.empty() ) {
     362                actual = new CastExpr( actual, newType );
     363            } else {
     364                delete newType;
     365            } // if
     366        }
     367
     368        void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
    416369///   std::cout << "function is ";
    417370///   function->print( std::cout );
    418   for( std::list< DeclarationWithType* >::const_iterator param = function->get_parameters().begin(); param != function->get_parameters().end(); ++param, ++arg ) {
     371            for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->get_parameters().end(); ++param, ++arg ) {
    419372///     std::cout << "parameter is ";
    420373///     (*param)->print( std::cout );
    421374///     std::cout << std::endl << "argument is ";
    422375///     (*arg)->print( std::cout );
    423     assert( arg != appExpr->get_args().end() );
    424     addCast( *arg, (*param)->get_type(), exprTyVars );
    425     boxParam( (*param)->get_type(), *arg, exprTyVars );
    426   }
    427 }
    428 
    429 void
    430 Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression* >::iterator &arg, const TyVarMap &tyVars )
    431 {
    432   std::list< Expression* >::iterator cur = arg;
    433   for( std::list< TypeDecl* >::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
    434     for( std::list< DeclarationWithType* >::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
    435       InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
    436       assert( inferParam != appExpr->get_inferParams().end() );
    437       Expression *newExpr = inferParam->second.expr->clone();
    438       addCast( newExpr, (*assert)->get_type(), tyVars );
    439       boxParam( (*assert)->get_type(), newExpr, tyVars );
    440       appExpr->get_args().insert( cur, newExpr );
    441     }
    442   }
    443 }
    444 
    445 void
    446 makeRetParm( FunctionType *funcType )
    447 {
    448   DeclarationWithType *retParm = funcType->get_returnVals().front();
    449 
    450   // make a new parameter that is a pointer to the type of the old return value
    451   retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
    452   funcType->get_parameters().push_front( retParm );
    453 
    454   // we don't need the return value any more
    455   funcType->get_returnVals().clear();
    456 }
    457 
    458 FunctionType *
    459 makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars )
    460 {
    461   // actually make the adapter type
    462   FunctionType *adapter = adaptee->clone();
    463   if( !adapter->get_returnVals().empty() && isPolyVal( adapter->get_returnVals().front()->get_type(), tyVars ) ) {
    464     makeRetParm( adapter );
    465   }
    466   adapter->get_parameters().push_front( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
    467   return adapter;
    468 }
    469 
    470 Expression*
    471 makeAdapterArg( DeclarationWithType *param, DeclarationWithType *arg, DeclarationWithType *realParam, const TyVarMap &tyVars )
    472 {
    473   assert( param );
    474   assert( arg );
     376                assert( arg != appExpr->get_args().end() );
     377                addCast( *arg, (*param)->get_type(), exprTyVars );
     378                boxParam( (*param)->get_type(), *arg, exprTyVars );
     379            } // for
     380        }
     381
     382        void Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
     383            std::list< Expression *>::iterator cur = arg;
     384            for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
     385                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
     386                    InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
     387                    assert( inferParam != appExpr->get_inferParams().end() );
     388                    Expression *newExpr = inferParam->second.expr->clone();
     389                    addCast( newExpr, (*assert)->get_type(), tyVars );
     390                    boxParam( (*assert)->get_type(), newExpr, tyVars );
     391                    appExpr->get_args().insert( cur, newExpr );
     392                } // for
     393            } // for
     394        }
     395
     396        void makeRetParm( FunctionType *funcType ) {
     397            DeclarationWithType *retParm = funcType->get_returnVals().front();
     398
     399            // make a new parameter that is a pointer to the type of the old return value
     400            retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
     401            funcType->get_parameters().push_front( retParm );
     402
     403            // we don't need the return value any more
     404            funcType->get_returnVals().clear();
     405        }
     406
     407        FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars ) {
     408            // actually make the adapter type
     409            FunctionType *adapter = adaptee->clone();
     410            if ( !adapter->get_returnVals().empty() && isPolyVal( adapter->get_returnVals().front()->get_type(), tyVars ) ) {
     411                makeRetParm( adapter );
     412            } // if
     413            adapter->get_parameters().push_front( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
     414            return adapter;
     415        }
     416
     417        Expression *makeAdapterArg( DeclarationWithType *param, DeclarationWithType *arg, DeclarationWithType *realParam, const TyVarMap &tyVars ) {
     418            assert( param );
     419            assert( arg );
    475420///   std::cout << "arg type is ";
    476421///   arg->get_type()->print( std::cout );
     
    479424///   std::cout << " tyVars are: ";
    480425///   printTyVarMap( std::cout, tyVars );
    481   if( isPolyVal( realParam->get_type(), tyVars ) ) {
    482 ///     if( dynamic_cast< PointerType* >( arg->get_type() ) ) {
     426            if ( isPolyVal( realParam->get_type(), tyVars ) ) {
     427///     if ( dynamic_cast< PointerType *>( arg->get_type() ) ) {
    483428///       return new CastExpr( new VariableExpr( param ), arg->get_type()->clone() );
    484429///     } else {
    485       UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
    486       deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
    487       deref->get_results().push_back( arg->get_type()->clone() );
    488       return deref;
     430                UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
     431                deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
     432                deref->get_results().push_back( arg->get_type()->clone() );
     433                return deref;
    489434///     }
    490   }
    491   return new VariableExpr( param );
    492 }
    493 
    494 void
    495 addAdapterParams( ApplicationExpr *adapteeApp, std::list< DeclarationWithType* >::iterator arg, std::list< DeclarationWithType* >::iterator param, std::list< DeclarationWithType* >::iterator paramEnd, std::list< DeclarationWithType* >::iterator realParam, const TyVarMap &tyVars )
    496 {
    497   UniqueName paramNamer( "_p" );
    498   for( ; param != paramEnd; ++param, ++arg, ++realParam ) {
    499     if( (*param)->get_name() == "" ) {
    500       (*param)->set_name( paramNamer.newName() );
    501       (*param)->set_linkage( LinkageSpec::C );
    502     }
    503     adapteeApp->get_args().push_back( makeAdapterArg( *param, *arg, *realParam, tyVars ) );
    504   }
    505 }
    506 
    507 FunctionDecl *
    508 Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars )
    509 {
    510   FunctionType *adapterType = makeAdapterType( adaptee, tyVars );
    511   adapterType = ScrubTyVars::scrub( adapterType, tyVars );
    512   DeclarationWithType *adapteeDecl = adapterType->get_parameters().front();
    513   adapteeDecl->set_name( "_adaptee" );
    514   ApplicationExpr *adapteeApp = new ApplicationExpr( new CastExpr( new VariableExpr( adapteeDecl ), new PointerType( Type::Qualifiers(), realType ) ) );
    515   Statement *bodyStmt;
    516  
    517   std::list< TypeDecl* >::iterator tyArg = realType->get_forall().begin();
    518   std::list< TypeDecl* >::iterator tyParam = adapterType->get_forall().begin();
    519   std::list< TypeDecl* >::iterator realTyParam = adaptee->get_forall().begin();
    520   for( ; tyParam != adapterType->get_forall().end(); ++tyArg, ++tyParam, ++realTyParam ) {
    521     assert( tyArg != realType->get_forall().end() );
    522     std::list< DeclarationWithType* >::iterator assertArg = (*tyArg)->get_assertions().begin();
    523     std::list< DeclarationWithType* >::iterator assertParam = (*tyParam)->get_assertions().begin();
    524     std::list< DeclarationWithType* >::iterator realAssertParam = (*realTyParam)->get_assertions().begin();
    525     for( ; assertParam != (*tyParam)->get_assertions().end(); ++assertArg, ++assertParam, ++realAssertParam ) {
    526       assert( assertArg != (*tyArg)->get_assertions().end() );
    527       adapteeApp->get_args().push_back( makeAdapterArg( *assertParam, *assertArg, *realAssertParam, tyVars ) );
    528     }
    529   }
    530  
    531   std::list< DeclarationWithType* >::iterator arg = realType->get_parameters().begin();
    532   std::list< DeclarationWithType* >::iterator param = adapterType->get_parameters().begin();
    533   std::list< DeclarationWithType* >::iterator realParam = adaptee->get_parameters().begin();
    534   param++;              // skip adaptee parameter
    535   if( realType->get_returnVals().empty() ) {
    536     addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
    537     bodyStmt = new ExprStmt( noLabels, adapteeApp );
    538   } else if( isPolyVal( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
    539     if( (*param)->get_name() == "" ) {
    540       (*param)->set_name( "_ret" );
    541       (*param)->set_linkage( LinkageSpec::C );
    542     }
    543     UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
    544     UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
    545     deref->get_args().push_back( new CastExpr( new VariableExpr( *param++ ), new PointerType( Type::Qualifiers(), realType->get_returnVals().front()->get_type()->clone() ) ) );
    546     assign->get_args().push_back( deref );
    547     addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
    548     assign->get_args().push_back( adapteeApp );
    549     bodyStmt = new ExprStmt( noLabels, assign );
    550   } else {
    551     // adapter for a function that returns a monomorphic value
    552     addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
    553     bodyStmt = new ReturnStmt( noLabels, adapteeApp );
    554   }
    555   CompoundStmt *adapterBody = new CompoundStmt( noLabels );
    556   adapterBody->get_kids().push_back( bodyStmt );
    557   return new FunctionDecl( "_adapter" + mangleName, Declaration::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false );
    558 }
    559 
    560 void
    561 Pass1::passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars )
    562 {
    563   std::list< DeclarationWithType* > &paramList = functionType->get_parameters();
    564   std::list< FunctionType* > functions;
    565   for( std::list< TypeDecl* >::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
    566     for( std::list< DeclarationWithType* >::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
    567       findFunction( (*assert)->get_type(), functions, exprTyVars, needsAdapter );
    568     }
    569   }
    570   for( std::list< DeclarationWithType* >::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
    571     findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter );
    572   }
    573   std::set< std::string > adaptersDone;
    574   for( std::list< FunctionType* >::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
    575     FunctionType *realFunction = (*funType)->clone();
    576     assert( env );
    577     env->apply( realFunction );
    578     std::string mangleName = SymTab::Mangler::mangle( realFunction );
    579     if( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
    580       std::map< std::string, FunctionDecl* >::iterator adapter = adapters.find( mangleName );
    581       if( adapter == adapters.end() ) {
    582         FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
    583         adapter = adapters.insert( adapters.begin(), std::pair< std::string, FunctionDecl* >( mangleName, newAdapter ) );
    584         stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
    585       }
    586       assert( adapter != adapters.end() );
    587       appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
    588       adaptersDone.insert( adaptersDone.begin(), mangleName );
    589     }
    590   }
    591 }
    592 
    593 TypeInstType*
    594 isPolyPtr( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars )
    595 {
    596   if( PointerType *ptr = dynamic_cast< PointerType* >( type ) ) {
    597     return isPolyType( ptr->get_base(), env, tyVars );
    598   } else if( env ) {
    599     if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
    600       if( Type *newType = env->lookup( typeInst->get_name() ) ) {
    601         return isPolyPtr( newType, env, tyVars );
    602       }
    603     }
    604   }
    605   return 0;
    606 }
    607 
    608 TypeInstType*
    609 isPolyPtrPtr( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars )
    610 {
    611   if( PointerType *ptr = dynamic_cast< PointerType* >( type ) ) {
    612     return isPolyPtr( ptr->get_base(), env, tyVars );
    613   } else if( env ) {
    614     if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
    615       if( Type *newType = env->lookup( typeInst->get_name() ) ) {
    616         return isPolyPtrPtr( newType, env, tyVars );
    617       }
    618     }
    619   }
    620   return 0;
    621 }
    622 
    623 Expression *
    624 makeIncrDecrExpr( ApplicationExpr *appExpr, std::string polyName, bool isIncr )
    625 {
    626   NameExpr *opExpr;
    627   if( isIncr ) {
    628     opExpr = new NameExpr( "?+=?" );
    629   } else {
    630     opExpr = new NameExpr( "?-=?" );
    631   }
    632   UntypedExpr *addAssign = new UntypedExpr( opExpr );
    633   if( AddressExpr *address = dynamic_cast< AddressExpr* >( appExpr->get_args().front() ) ) {
    634     addAssign->get_args().push_back( address->get_arg() );
    635   } else {
    636     addAssign->get_args().push_back( appExpr->get_args().front() );
    637   }
    638   addAssign->get_args().push_back( new NameExpr( polyName ) );
    639   addAssign->get_results().front() = appExpr->get_results().front()->clone();
    640   if( appExpr->get_env() ) {
    641     addAssign->set_env( appExpr->get_env() );
    642     appExpr->set_env( 0 );
    643   }
    644   appExpr->get_args().clear();
    645   delete appExpr;
    646   return addAssign;
    647 }
    648 
    649 Expression*
    650 Pass1::handleIntrinsics( ApplicationExpr *appExpr )
    651 {
    652   if( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( appExpr->get_function() ) ) {
    653     if( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
    654       if( varExpr->get_var()->get_name() == "?[?]" ) {
    655         assert( !appExpr->get_results().empty() );
    656         assert( appExpr->get_args().size() == 2 );
    657         TypeInstType *typeInst1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), env, scopeTyVars );
    658         TypeInstType *typeInst2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), env, scopeTyVars );
    659         assert( !typeInst1 || !typeInst2 );
    660         UntypedExpr *ret = 0;
    661         if( typeInst1 || typeInst2 ) {
    662           ret = new UntypedExpr( new NameExpr( "?+?" ) );
    663         }
    664         if( typeInst1 ) {
    665           UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
    666           multiply->get_args().push_back( appExpr->get_args().back() );
    667           multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
    668           ret->get_args().push_back( appExpr->get_args().front() );
    669           ret->get_args().push_back( multiply );
    670         } else if( typeInst2 ) {
    671           UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
    672           multiply->get_args().push_back( appExpr->get_args().front() );
    673           multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) );
    674           ret->get_args().push_back( multiply );
    675           ret->get_args().push_back( appExpr->get_args().back() );
    676         }
    677         if( typeInst1 || typeInst2 ) {
    678           ret->get_results().push_front( appExpr->get_results().front()->clone() );
    679           if( appExpr->get_env() ) {
    680             ret->set_env( appExpr->get_env() );
    681             appExpr->set_env( 0 );
    682           }
    683           appExpr->get_args().clear();
    684           delete appExpr;
    685           return ret;
    686         }
    687       } else if( varExpr->get_var()->get_name() == "*?" ) {
    688         assert( !appExpr->get_results().empty() );
    689         assert( !appExpr->get_args().empty() );
    690         if( isPolyType( appExpr->get_results().front(), env, scopeTyVars ) ) {
    691           Expression *ret = appExpr->get_args().front();
    692           delete ret->get_results().front();
    693           ret->get_results().front() = appExpr->get_results().front()->clone();
    694           if( appExpr->get_env() ) {
    695             ret->set_env( appExpr->get_env() );
    696             appExpr->set_env( 0 );
    697           }
    698           appExpr->get_args().clear();
    699           delete appExpr;
    700           return ret;
    701         }
    702       } else if( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
    703         assert( !appExpr->get_results().empty() );
    704         assert( appExpr->get_args().size() == 1 );
    705         if( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
    706           Type *tempType = appExpr->get_results().front()->clone();
    707           if( env ) {
    708             env->apply( tempType );
    709           }
    710           ObjectDecl *newObj = makeTemporary( tempType );
    711           VariableExpr *tempExpr = new VariableExpr( newObj );
    712           UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
    713           assignExpr->get_args().push_back( tempExpr->clone() );
    714           if( AddressExpr *address = dynamic_cast< AddressExpr* >( appExpr->get_args().front() ) ) {
    715             assignExpr->get_args().push_back( address->get_arg()->clone() );
    716           } else {
    717             assignExpr->get_args().push_back( appExpr->get_args().front()->clone() );
    718           }
    719           CommaExpr *firstComma = new CommaExpr( assignExpr, makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "?++" ) );
    720           return new CommaExpr( firstComma, tempExpr );
    721         }
    722       } else if( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
    723         assert( !appExpr->get_results().empty() );
    724         assert( appExpr->get_args().size() == 1 );
    725         if( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
    726            return makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "++?" );
    727         }
    728       } else if( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
    729         assert( !appExpr->get_results().empty() );
    730         assert( appExpr->get_args().size() == 2 );
    731         TypeInstType *typeInst1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), env, scopeTyVars );
    732         TypeInstType *typeInst2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), env, scopeTyVars );
    733         if( typeInst1 && typeInst2 ) {
    734           UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
    735           divide->get_args().push_back( appExpr );
    736           divide->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
    737           divide->get_results().push_front( appExpr->get_results().front()->clone() );
    738           if( appExpr->get_env() ) {
    739             divide->set_env( appExpr->get_env() );
    740             appExpr->set_env( 0 );
    741           }
    742           return divide;
    743         } else if( typeInst1 ) {
    744           UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
    745           multiply->get_args().push_back( appExpr->get_args().back() );
    746           multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
    747           appExpr->get_args().back() = multiply;
    748         } else if( typeInst2 ) {
    749           UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
    750           multiply->get_args().push_back( appExpr->get_args().front() );
    751           multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) );
    752           appExpr->get_args().front() = multiply;
    753         }
    754       } else if( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
    755         assert( !appExpr->get_results().empty() );
    756         assert( appExpr->get_args().size() == 2 );
    757         TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars );
    758         if( typeInst ) {
    759           UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
    760           multiply->get_args().push_back( appExpr->get_args().back() );
    761           multiply->get_args().push_back( new NameExpr( typeInst->get_name() ) );
    762           appExpr->get_args().back() = multiply;
    763         }
    764       }
    765       return appExpr;
    766     }
    767   }
    768   return 0;
    769 }
    770 
    771 Expression*
    772 Pass1::mutate( ApplicationExpr *appExpr )
    773 {
     435            } // if
     436            return new VariableExpr( param );
     437        }
     438
     439        void addAdapterParams( ApplicationExpr *adapteeApp, std::list< DeclarationWithType *>::iterator arg, std::list< DeclarationWithType *>::iterator param, std::list< DeclarationWithType *>::iterator paramEnd, std::list< DeclarationWithType *>::iterator realParam, const TyVarMap &tyVars ) {
     440            UniqueName paramNamer( "_p" );
     441            for ( ; param != paramEnd; ++param, ++arg, ++realParam ) {
     442                if ( (*param)->get_name() == "" ) {
     443                    (*param)->set_name( paramNamer.newName() );
     444                    (*param)->set_linkage( LinkageSpec::C );
     445                } // if
     446                adapteeApp->get_args().push_back( makeAdapterArg( *param, *arg, *realParam, tyVars ) );
     447            } // for
     448        }
     449
     450        FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
     451            FunctionType *adapterType = makeAdapterType( adaptee, tyVars );
     452            adapterType = ScrubTyVars::scrub( adapterType, tyVars );
     453            DeclarationWithType *adapteeDecl = adapterType->get_parameters().front();
     454            adapteeDecl->set_name( "_adaptee" );
     455            ApplicationExpr *adapteeApp = new ApplicationExpr( new CastExpr( new VariableExpr( adapteeDecl ), new PointerType( Type::Qualifiers(), realType ) ) );
     456            Statement *bodyStmt;
     457 
     458            std::list< TypeDecl *>::iterator tyArg = realType->get_forall().begin();
     459            std::list< TypeDecl *>::iterator tyParam = adapterType->get_forall().begin();
     460            std::list< TypeDecl *>::iterator realTyParam = adaptee->get_forall().begin();
     461            for ( ; tyParam != adapterType->get_forall().end(); ++tyArg, ++tyParam, ++realTyParam ) {
     462                assert( tyArg != realType->get_forall().end() );
     463                std::list< DeclarationWithType *>::iterator assertArg = (*tyArg)->get_assertions().begin();
     464                std::list< DeclarationWithType *>::iterator assertParam = (*tyParam)->get_assertions().begin();
     465                std::list< DeclarationWithType *>::iterator realAssertParam = (*realTyParam)->get_assertions().begin();
     466                for ( ; assertParam != (*tyParam)->get_assertions().end(); ++assertArg, ++assertParam, ++realAssertParam ) {
     467                    assert( assertArg != (*tyArg)->get_assertions().end() );
     468                    adapteeApp->get_args().push_back( makeAdapterArg( *assertParam, *assertArg, *realAssertParam, tyVars ) );
     469                } // for
     470            } // for
     471 
     472            std::list< DeclarationWithType *>::iterator arg = realType->get_parameters().begin();
     473            std::list< DeclarationWithType *>::iterator param = adapterType->get_parameters().begin();
     474            std::list< DeclarationWithType *>::iterator realParam = adaptee->get_parameters().begin();
     475            param++;            // skip adaptee parameter
     476            if ( realType->get_returnVals().empty() ) {
     477                addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
     478                bodyStmt = new ExprStmt( noLabels, adapteeApp );
     479            } else if ( isPolyVal( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
     480                if ( (*param)->get_name() == "" ) {
     481                    (*param)->set_name( "_ret" );
     482                    (*param)->set_linkage( LinkageSpec::C );
     483                } // if
     484                UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
     485                UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
     486                deref->get_args().push_back( new CastExpr( new VariableExpr( *param++ ), new PointerType( Type::Qualifiers(), realType->get_returnVals().front()->get_type()->clone() ) ) );
     487                assign->get_args().push_back( deref );
     488                addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
     489                assign->get_args().push_back( adapteeApp );
     490                bodyStmt = new ExprStmt( noLabels, assign );
     491            } else {
     492                // adapter for a function that returns a monomorphic value
     493                addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
     494                bodyStmt = new ReturnStmt( noLabels, adapteeApp );
     495            } // if
     496            CompoundStmt *adapterBody = new CompoundStmt( noLabels );
     497            adapterBody->get_kids().push_back( bodyStmt );
     498            return new FunctionDecl( "_adapter" + mangleName, Declaration::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false );
     499        }
     500
     501        void Pass1::passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars ) {
     502            std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
     503            std::list< FunctionType *> functions;
     504            for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
     505                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
     506                    findFunction( (*assert)->get_type(), functions, exprTyVars, needsAdapter );
     507                } // for
     508            } // for
     509            for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
     510                findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter );
     511            } // for
     512            std::set< std::string > adaptersDone;
     513            for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
     514                FunctionType *realFunction = (*funType)->clone();
     515                assert( env );
     516                env->apply( realFunction );
     517                std::string mangleName = SymTab::Mangler::mangle( realFunction );
     518                if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
     519                    std::map< std::string, FunctionDecl *>::iterator adapter = adapters.find( mangleName );
     520                    if ( adapter == adapters.end() ) {
     521                        FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
     522                        adapter = adapters.insert( adapters.begin(), std::pair< std::string, FunctionDecl *>( mangleName, newAdapter ) );
     523                        stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
     524                    } // if
     525                    assert( adapter != adapters.end() );
     526                    appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
     527                    adaptersDone.insert( adaptersDone.begin(), mangleName );
     528                } // if
     529            } // for
     530        }
     531
     532        TypeInstType *isPolyPtr( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars ) {
     533            if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
     534                return isPolyType( ptr->get_base(), env, tyVars );
     535            } else if ( env ) {
     536                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
     537                    if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
     538                        return isPolyPtr( newType, env, tyVars );
     539                    } // if
     540                } // if
     541            } // if
     542            return 0;
     543        }
     544
     545        TypeInstType *isPolyPtrPtr( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars ) {
     546            if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
     547                return isPolyPtr( ptr->get_base(), env, tyVars );
     548            } else if ( env ) {
     549                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
     550                    if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
     551                        return isPolyPtrPtr( newType, env, tyVars );
     552                    } // if
     553                } // if
     554            } // if
     555            return 0;
     556        }
     557
     558        Expression *makeIncrDecrExpr( ApplicationExpr *appExpr, std::string polyName, bool isIncr ) {
     559            NameExpr *opExpr;
     560            if ( isIncr ) {
     561                opExpr = new NameExpr( "?+=?" );
     562            } else {
     563                opExpr = new NameExpr( "?-=?" );
     564            } // if
     565            UntypedExpr *addAssign = new UntypedExpr( opExpr );
     566            if ( AddressExpr *address = dynamic_cast< AddressExpr *>( appExpr->get_args().front() ) ) {
     567                addAssign->get_args().push_back( address->get_arg() );
     568            } else {
     569                addAssign->get_args().push_back( appExpr->get_args().front() );
     570            } // if
     571            addAssign->get_args().push_back( new NameExpr( polyName ) );
     572            addAssign->get_results().front() = appExpr->get_results().front()->clone();
     573            if ( appExpr->get_env() ) {
     574                addAssign->set_env( appExpr->get_env() );
     575                appExpr->set_env( 0 );
     576            } // if
     577            appExpr->get_args().clear();
     578            delete appExpr;
     579            return addAssign;
     580        }
     581
     582        Expression *Pass1::handleIntrinsics( ApplicationExpr *appExpr ) {
     583            if ( VariableExpr *varExpr = dynamic_cast< VariableExpr *>( appExpr->get_function() ) ) {
     584                if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
     585                    if ( varExpr->get_var()->get_name() == "?[?]" ) {
     586                        assert( !appExpr->get_results().empty() );
     587                        assert( appExpr->get_args().size() == 2 );
     588                        TypeInstType *typeInst1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), env, scopeTyVars );
     589                        TypeInstType *typeInst2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), env, scopeTyVars );
     590                        assert( !typeInst1 || !typeInst2 );
     591                        UntypedExpr *ret = 0;
     592                        if ( typeInst1 || typeInst2 ) {
     593                            ret = new UntypedExpr( new NameExpr( "?+?" ) );
     594                        } // if
     595                        if ( typeInst1 ) {
     596                            UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
     597                            multiply->get_args().push_back( appExpr->get_args().back() );
     598                            multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
     599                            ret->get_args().push_back( appExpr->get_args().front() );
     600                            ret->get_args().push_back( multiply );
     601                        } else if ( typeInst2 ) {
     602                            UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
     603                            multiply->get_args().push_back( appExpr->get_args().front() );
     604                            multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) );
     605                            ret->get_args().push_back( multiply );
     606                            ret->get_args().push_back( appExpr->get_args().back() );
     607                        } // if
     608                        if ( typeInst1 || typeInst2 ) {
     609                            ret->get_results().push_front( appExpr->get_results().front()->clone() );
     610                            if ( appExpr->get_env() ) {
     611                                ret->set_env( appExpr->get_env() );
     612                                appExpr->set_env( 0 );
     613                            } // if
     614                            appExpr->get_args().clear();
     615                            delete appExpr;
     616                            return ret;
     617                        } // if
     618                    } else if ( varExpr->get_var()->get_name() == "*?" ) {
     619                        assert( !appExpr->get_results().empty() );
     620                        assert( !appExpr->get_args().empty() );
     621                        if ( isPolyType( appExpr->get_results().front(), env, scopeTyVars ) ) {
     622                            Expression *ret = appExpr->get_args().front();
     623                            delete ret->get_results().front();
     624                            ret->get_results().front() = appExpr->get_results().front()->clone();
     625                            if ( appExpr->get_env() ) {
     626                                ret->set_env( appExpr->get_env() );
     627                                appExpr->set_env( 0 );
     628                            } // if
     629                            appExpr->get_args().clear();
     630                            delete appExpr;
     631                            return ret;
     632                        } // if
     633                    } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
     634                        assert( !appExpr->get_results().empty() );
     635                        assert( appExpr->get_args().size() == 1 );
     636                        if ( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
     637                            Type *tempType = appExpr->get_results().front()->clone();
     638                            if ( env ) {
     639                                env->apply( tempType );
     640                            } // if
     641                            ObjectDecl *newObj = makeTemporary( tempType );
     642                            VariableExpr *tempExpr = new VariableExpr( newObj );
     643                            UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
     644                            assignExpr->get_args().push_back( tempExpr->clone() );
     645                            if ( AddressExpr *address = dynamic_cast< AddressExpr *>( appExpr->get_args().front() ) ) {
     646                                assignExpr->get_args().push_back( address->get_arg()->clone() );
     647                            } else {
     648                                assignExpr->get_args().push_back( appExpr->get_args().front()->clone() );
     649                            } // if
     650                            CommaExpr *firstComma = new CommaExpr( assignExpr, makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "?++" ) );
     651                            return new CommaExpr( firstComma, tempExpr );
     652                        } // if
     653                    } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
     654                        assert( !appExpr->get_results().empty() );
     655                        assert( appExpr->get_args().size() == 1 );
     656                        if ( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
     657                            return makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "++?" );
     658                        } // if
     659                    } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
     660                        assert( !appExpr->get_results().empty() );
     661                        assert( appExpr->get_args().size() == 2 );
     662                        TypeInstType *typeInst1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), env, scopeTyVars );
     663                        TypeInstType *typeInst2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), env, scopeTyVars );
     664                        if ( typeInst1 && typeInst2 ) {
     665                            UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
     666                            divide->get_args().push_back( appExpr );
     667                            divide->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
     668                            divide->get_results().push_front( appExpr->get_results().front()->clone() );
     669                            if ( appExpr->get_env() ) {
     670                                divide->set_env( appExpr->get_env() );
     671                                appExpr->set_env( 0 );
     672                            } // if
     673                            return divide;
     674                        } else if ( typeInst1 ) {
     675                            UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
     676                            multiply->get_args().push_back( appExpr->get_args().back() );
     677                            multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
     678                            appExpr->get_args().back() = multiply;
     679                        } else if ( typeInst2 ) {
     680                            UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
     681                            multiply->get_args().push_back( appExpr->get_args().front() );
     682                            multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) );
     683                            appExpr->get_args().front() = multiply;
     684                        } // if
     685                    } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
     686                        assert( !appExpr->get_results().empty() );
     687                        assert( appExpr->get_args().size() == 2 );
     688                        TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars );
     689                        if ( typeInst ) {
     690                            UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
     691                            multiply->get_args().push_back( appExpr->get_args().back() );
     692                            multiply->get_args().push_back( new NameExpr( typeInst->get_name() ) );
     693                            appExpr->get_args().back() = multiply;
     694                        } // if
     695                    } // if
     696                    return appExpr;
     697                } // if
     698            } // if
     699            return 0;
     700        }
     701
     702        Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
    774703///     std::cerr << "mutate appExpr: ";
    775 ///     for( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
     704///     for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
    776705///       std::cerr << i->first << " ";
    777706///     }
    778707///     std::cerr << "\n";
    779   bool oldUseRetval = useRetval;
    780   useRetval = false;
    781   appExpr->get_function()->acceptMutator( *this );
    782   mutateAll( appExpr->get_args(), *this );
    783   useRetval = oldUseRetval;
    784  
    785   assert( !appExpr->get_function()->get_results().empty() );
    786   PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
    787   assert( pointer );
    788   FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
    789   assert( function );
    790  
    791   if( Expression *newExpr = handleIntrinsics( appExpr ) ) {
    792     return newExpr;
    793   }
    794  
    795   Expression *ret = appExpr;
    796  
    797   std::list< Expression* >::iterator arg = appExpr->get_args().begin();
    798   std::list< Expression* >::iterator paramBegin = appExpr->get_args().begin();
    799  
    800   std::string typeName;
    801   if( isPolyRet( function, typeName ) ) {
    802     ret = addPolyRetParam( appExpr, function, typeName, arg );
    803   } else if( needsAdapter( function, scopeTyVars ) ) {
     708            bool oldUseRetval = useRetval;
     709            useRetval = false;
     710            appExpr->get_function()->acceptMutator( *this );
     711            mutateAll( appExpr->get_args(), *this );
     712            useRetval = oldUseRetval;
     713 
     714            assert( !appExpr->get_function()->get_results().empty() );
     715            PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
     716            assert( pointer );
     717            FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
     718            assert( function );
     719 
     720            if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
     721                return newExpr;
     722            } // if
     723 
     724            Expression *ret = appExpr;
     725 
     726            std::list< Expression *>::iterator arg = appExpr->get_args().begin();
     727            std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
     728 
     729            std::string typeName;
     730            if ( isPolyRet( function, typeName ) ) {
     731                ret = addPolyRetParam( appExpr, function, typeName, arg );
     732            } else if ( needsAdapter( function, scopeTyVars ) ) {
    804733///     std::cerr << "needs adapter: ";
    805 ///     for( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
     734///     for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
    806735///       std::cerr << i->first << " ";
    807736///     }
    808737///     std::cerr << "\n";
    809     // change the application so it calls the adapter rather than the passed function
    810     ret = applyAdapter( appExpr, function, arg, scopeTyVars );
    811   }
    812   arg = appExpr->get_args().begin();
    813  
    814   TyVarMap exprTyVars;
    815   makeTyVarMap( function, exprTyVars );
    816  
    817   passTypeVars( appExpr, arg, exprTyVars );
    818   addInferredParams( appExpr, function, arg, exprTyVars );
    819 
    820   arg = paramBegin;
    821  
    822   boxParams( appExpr, function, arg, exprTyVars );
    823 
    824   passAdapters( appExpr, function, exprTyVars );
    825 
    826   return ret;
    827 }
    828 
    829 Expression *
    830 Pass1::mutate( UntypedExpr *expr )
    831 {
    832   if( !expr->get_results().empty() && isPolyType( expr->get_results().front(), env, scopeTyVars ) ) {
    833     if( NameExpr *name = dynamic_cast< NameExpr* >( expr->get_function() ) ) {
    834       if( name->get_name() == "*?" ) {
    835         Expression *ret = expr->get_args().front();
    836         expr->get_args().clear();
    837         delete expr;
    838         return ret->acceptMutator( *this );
    839       }
    840     }
    841   }
    842   return PolyMutator::mutate( expr );
    843 }
    844 
    845 Expression *
    846 Pass1::mutate( AddressExpr *addrExpr )
    847 {
    848   assert( !addrExpr->get_arg()->get_results().empty() );
    849   mutateExpression( addrExpr->get_arg() );
    850   if( isPolyType( addrExpr->get_arg()->get_results().front(), env, scopeTyVars ) ) {
    851     Expression *ret = addrExpr->get_arg();
    852     delete ret->get_results().front();
    853     ret->get_results().front() = addrExpr->get_results().front()->clone();
    854     addrExpr->set_arg( 0 );
    855     delete addrExpr;
    856     return ret;
    857   } else {
    858     return addrExpr;
    859   }
    860 }
    861 
    862 Statement*
    863 Pass1::mutate(ReturnStmt *retStmt)
    864 {
    865   // a cast expr on a polymorphic return value is either redundant or invalid
    866   while( CastExpr *castExpr = dynamic_cast< CastExpr* >( retStmt->get_expr() ) ) {
    867     retStmt->set_expr( castExpr->get_arg() );
    868     retStmt->get_expr()->set_env( castExpr->get_env() );
    869     castExpr->set_env( 0 );
    870     castExpr->set_arg( 0 );
    871     delete castExpr;
    872   }
    873   if( retval && retStmt->get_expr() ) {
    874     assert( !retStmt->get_expr()->get_results().empty() );
    875     if( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
     738                // change the application so it calls the adapter rather than the passed function
     739                ret = applyAdapter( appExpr, function, arg, scopeTyVars );
     740            } // if
     741            arg = appExpr->get_args().begin();
     742 
     743            TyVarMap exprTyVars;
     744            makeTyVarMap( function, exprTyVars );
     745 
     746            passTypeVars( appExpr, arg, exprTyVars );
     747            addInferredParams( appExpr, function, arg, exprTyVars );
     748
     749            arg = paramBegin;
     750 
     751            boxParams( appExpr, function, arg, exprTyVars );
     752
     753            passAdapters( appExpr, function, exprTyVars );
     754
     755            return ret;
     756        }
     757
     758        Expression *Pass1::mutate( UntypedExpr *expr ) {
     759            if ( !expr->get_results().empty() && isPolyType( expr->get_results().front(), env, scopeTyVars ) ) {
     760                if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
     761                    if ( name->get_name() == "*?" ) {
     762                        Expression *ret = expr->get_args().front();
     763                        expr->get_args().clear();
     764                        delete expr;
     765                        return ret->acceptMutator( *this );
     766                    } // if
     767                } // if
     768            } // if
     769            return PolyMutator::mutate( expr );
     770        }
     771
     772        Expression *Pass1::mutate( AddressExpr *addrExpr ) {
     773            assert( !addrExpr->get_arg()->get_results().empty() );
     774            mutateExpression( addrExpr->get_arg() );
     775            if ( isPolyType( addrExpr->get_arg()->get_results().front(), env, scopeTyVars ) ) {
     776                Expression *ret = addrExpr->get_arg();
     777                delete ret->get_results().front();
     778                ret->get_results().front() = addrExpr->get_results().front()->clone();
     779                addrExpr->set_arg( 0 );
     780                delete addrExpr;
     781                return ret;
     782            } else {
     783                return addrExpr;
     784            } // if
     785        }
     786
     787        Statement *
     788        Pass1::mutate(ReturnStmt *retStmt) {
     789            // a cast expr on a polymorphic return value is either redundant or invalid
     790            while ( CastExpr *castExpr = dynamic_cast< CastExpr *>( retStmt->get_expr() ) ) {
     791                retStmt->set_expr( castExpr->get_arg() );
     792                retStmt->get_expr()->set_env( castExpr->get_env() );
     793                castExpr->set_env( 0 );
     794                castExpr->set_arg( 0 );
     795                delete castExpr;
     796            }
     797            if ( retval && retStmt->get_expr() ) {
     798                assert( !retStmt->get_expr()->get_results().empty() );
     799                if ( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
    876800///       retStmt->set_expr( mutateExpression( retStmt->get_expr() ) );
    877       TypeInstType *typeInst = dynamic_cast< TypeInstType* >( retval->get_type() );
    878       assert( typeInst );
    879       std::map< std::string, DeclarationWithType* >::const_iterator assignIter = assignOps.find( typeInst->get_name() );
    880       if( assignIter == assignOps.end() ) {
    881         throw SemanticError( "Attempt to return dtype or ftype object in ", retStmt->get_expr() );
    882       }
    883       ApplicationExpr *assignExpr = new ApplicationExpr( new VariableExpr( assignIter->second ) );
    884       Expression *retParm = new NameExpr( retval->get_name() );
    885       retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
    886       assignExpr->get_args().push_back( retParm );
    887       assignExpr->get_args().push_back( retStmt->get_expr() );
    888       stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( assignExpr ) ) );
    889     } else {
    890       useRetval = true;
    891       stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( retStmt->get_expr() ) ) );
    892       useRetval = false;
    893     }
    894     retStmt->set_expr( 0 );
    895   } else {
    896     retStmt->set_expr( mutateExpression( retStmt->get_expr() ) );
    897   }
    898   return retStmt;
    899 }
    900 
    901 Type*
    902 Pass1::mutate( PointerType *pointerType )
    903 {
    904   TyVarMap oldtyVars = scopeTyVars;
    905   makeTyVarMap( pointerType, scopeTyVars );
    906  
    907   Type* ret = Mutator::mutate( pointerType );
    908  
    909   scopeTyVars = oldtyVars;
    910   return ret;
    911 }
    912 
    913 Type*
    914 Pass1::mutate( FunctionType *functionType )
    915 {
    916   TyVarMap oldtyVars = scopeTyVars;
    917   makeTyVarMap( functionType, scopeTyVars );
    918  
    919   Type* ret = Mutator::mutate( functionType );
    920  
    921   scopeTyVars = oldtyVars;
    922   return ret;
    923 }
    924 
    925 void
    926 Pass1::doEndScope()
    927 {
    928   adapters.clear();
    929 }
     801                    TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() );
     802                    assert( typeInst );
     803                    std::map< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
     804                    if ( assignIter == assignOps.end() ) {
     805                        throw SemanticError( "Attempt to return dtype or ftype object in ", retStmt->get_expr() );
     806                    } // if
     807                    ApplicationExpr *assignExpr = new ApplicationExpr( new VariableExpr( assignIter->second ) );
     808                    Expression *retParm = new NameExpr( retval->get_name() );
     809                    retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
     810                    assignExpr->get_args().push_back( retParm );
     811                    assignExpr->get_args().push_back( retStmt->get_expr() );
     812                    stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( assignExpr ) ) );
     813                } else {
     814                    useRetval = true;
     815                    stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( retStmt->get_expr() ) ) );
     816                    useRetval = false;
     817                } // if
     818                retStmt->set_expr( 0 );
     819            } else {
     820                retStmt->set_expr( mutateExpression( retStmt->get_expr() ) );
     821            } // if
     822            return retStmt;
     823        }
     824
     825        Type *
     826        Pass1::mutate( PointerType *pointerType ) {
     827            TyVarMap oldtyVars = scopeTyVars;
     828            makeTyVarMap( pointerType, scopeTyVars );
     829 
     830            Type *ret = Mutator::mutate( pointerType );
     831 
     832            scopeTyVars = oldtyVars;
     833            return ret;
     834        }
     835
     836        Type *
     837        Pass1::mutate( FunctionType *functionType ) {
     838            TyVarMap oldtyVars = scopeTyVars;
     839            makeTyVarMap( functionType, scopeTyVars );
     840 
     841            Type *ret = Mutator::mutate( functionType );
     842 
     843            scopeTyVars = oldtyVars;
     844            return ret;
     845        }
     846
     847        void Pass1::doEndScope() {
     848            adapters.clear();
     849        }
    930850
    931851////////////////////////////////////////// Pass2 ////////////////////////////////////////////////////
    932852
    933 Pass2::Pass2()
    934 {
    935 }
    936 
    937 void
    938 Pass2::addAdapters( FunctionType *functionType )
    939 {
    940   std::list< DeclarationWithType* > &paramList = functionType->get_parameters();
    941   std::list< FunctionType* > functions;
    942   for( std::list< DeclarationWithType* >::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
    943     Type *orig = (*arg)->get_type();
    944     findAndReplaceFunction( orig, functions, scopeTyVars, needsAdapter );
    945     (*arg)->set_type( orig );
    946   }
    947   std::set< std::string > adaptersDone;
    948   for( std::list< FunctionType* >::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
    949     std::string mangleName = SymTab::Mangler::mangle( *funType );
    950     if( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
    951       paramList.push_front( new ObjectDecl( "_adapter" + mangleName, Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
    952       adaptersDone.insert( adaptersDone.begin(), mangleName );
    953     }
    954   }
     853        Pass2::Pass2() {}
     854
     855        void Pass2::addAdapters( FunctionType *functionType ) {
     856            std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
     857            std::list< FunctionType *> functions;
     858            for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
     859                Type *orig = (*arg)->get_type();
     860                findAndReplaceFunction( orig, functions, scopeTyVars, needsAdapter );
     861                (*arg)->set_type( orig );
     862            }
     863            std::set< std::string > adaptersDone;
     864            for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
     865                std::string mangleName = SymTab::Mangler::mangle( *funType );
     866                if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
     867                    paramList.push_front( new ObjectDecl( "_adapter" + mangleName, Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
     868                    adaptersDone.insert( adaptersDone.begin(), mangleName );
     869                }
     870            }
    955871///  deleteAll( functions );
    956 }
    957 
    958 template< typename DeclClass >
    959 DeclClass*
    960 Pass2::handleDecl( DeclClass *decl, Type *type )
    961 {
    962   DeclClass *ret = static_cast< DeclClass* >( Mutator::mutate( decl ) );
    963 
    964   return ret;
    965 }
    966 
    967 DeclarationWithType*
    968 Pass2::mutate( FunctionDecl *functionDecl )
    969 {
    970   return handleDecl( functionDecl, functionDecl->get_functionType() );
    971 }
    972 
    973 ObjectDecl*
    974 Pass2::mutate( ObjectDecl *objectDecl )
    975 {
    976   return handleDecl( objectDecl, objectDecl->get_type() );
    977 }
    978 
    979 TypeDecl*
    980 Pass2::mutate( TypeDecl *typeDecl )
    981 {
    982   scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
    983   if( typeDecl->get_base() ) {
    984     return handleDecl( typeDecl, typeDecl->get_base() );
    985   } else {
    986     return Mutator::mutate( typeDecl );
    987   }
    988 }
    989 
    990 TypedefDecl*
    991 Pass2::mutate( TypedefDecl *typedefDecl )
    992 {
    993   return handleDecl( typedefDecl, typedefDecl->get_base() );
    994 }
    995 
    996 Type*
    997 Pass2::mutate( PointerType *pointerType )
    998 {
    999   TyVarMap oldtyVars = scopeTyVars;
    1000   makeTyVarMap( pointerType, scopeTyVars );
    1001  
    1002   Type* ret = Mutator::mutate( pointerType );
    1003  
    1004   scopeTyVars = oldtyVars;
    1005   return ret;
    1006 }
    1007 
    1008 Type *
    1009 Pass2::mutate( FunctionType *funcType )
    1010 {
    1011   TyVarMap oldtyVars = scopeTyVars;
    1012   makeTyVarMap( funcType, scopeTyVars );
    1013  
    1014   std::string typeName;
    1015   if( isPolyRet( funcType, typeName ) ) {
    1016     DeclarationWithType *ret = funcType->get_returnVals().front();
    1017     ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) );
    1018     funcType->get_parameters().push_front( ret );
    1019     funcType->get_returnVals().pop_front();
    1020   }
    1021  
    1022   std::list< DeclarationWithType* >::iterator last = funcType->get_parameters().begin();
    1023   std::list< DeclarationWithType* > inferredParams;
    1024   ObjectDecl *newObj = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
     872        }
     873
     874        template< typename DeclClass >
     875        DeclClass *
     876        Pass2::handleDecl( DeclClass *decl, Type *type ) {
     877            DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
     878
     879            return ret;
     880        }
     881
     882        DeclarationWithType *
     883        Pass2::mutate( FunctionDecl *functionDecl ) {
     884            return handleDecl( functionDecl, functionDecl->get_functionType() );
     885        }
     886
     887        ObjectDecl *
     888        Pass2::mutate( ObjectDecl *objectDecl ) {
     889            return handleDecl( objectDecl, objectDecl->get_type() );
     890        }
     891
     892        TypeDecl *
     893        Pass2::mutate( TypeDecl *typeDecl ) {
     894            scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
     895            if ( typeDecl->get_base() ) {
     896                return handleDecl( typeDecl, typeDecl->get_base() );
     897            } else {
     898                return Mutator::mutate( typeDecl );
     899            }
     900        }
     901
     902        TypedefDecl *
     903        Pass2::mutate( TypedefDecl *typedefDecl ) {
     904            return handleDecl( typedefDecl, typedefDecl->get_base() );
     905        }
     906
     907        Type *
     908        Pass2::mutate( PointerType *pointerType ) {
     909            TyVarMap oldtyVars = scopeTyVars;
     910            makeTyVarMap( pointerType, scopeTyVars );
     911 
     912            Type *ret = Mutator::mutate( pointerType );
     913 
     914            scopeTyVars = oldtyVars;
     915            return ret;
     916        }
     917
     918        Type *Pass2::mutate( FunctionType *funcType ) {
     919            TyVarMap oldtyVars = scopeTyVars;
     920            makeTyVarMap( funcType, scopeTyVars );
     921 
     922            std::string typeName;
     923            if ( isPolyRet( funcType, typeName ) ) {
     924                DeclarationWithType *ret = funcType->get_returnVals().front();
     925                ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) );
     926                funcType->get_parameters().push_front( ret );
     927                funcType->get_returnVals().pop_front();
     928            }
     929 
     930            std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
     931            std::list< DeclarationWithType *> inferredParams;
     932            ObjectDecl *newObj = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
    1025933///   ObjectDecl *newFunPtr = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
    1026   for( std::list< TypeDecl* >::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
    1027     ObjectDecl *thisParm;
    1028     if( (*tyParm)->get_kind() == TypeDecl::Any ) {
    1029       thisParm = newObj->clone();
    1030       thisParm->set_name( (*tyParm)->get_name() );
    1031       last = funcType->get_parameters().insert( last, thisParm );
    1032       ++last;
    1033     }
    1034     for( std::list< DeclarationWithType* >::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
    1035 ///       *assert = (*assert)->acceptMutator( *this );
    1036       inferredParams.push_back( *assert );
    1037     }
    1038     (*tyParm)->get_assertions().clear();
    1039   }
    1040   delete newObj;
    1041   funcType->get_parameters().splice( last, inferredParams );
    1042   addAdapters( funcType );
    1043   mutateAll( funcType->get_returnVals(), *this );
    1044   mutateAll( funcType->get_parameters(), *this );
    1045  
    1046   scopeTyVars = oldtyVars;
    1047   return funcType;
    1048 }
     934            for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
     935                ObjectDecl *thisParm;
     936                if ( (*tyParm)->get_kind() == TypeDecl::Any ) {
     937                    thisParm = newObj->clone();
     938                    thisParm->set_name( (*tyParm)->get_name() );
     939                    last = funcType->get_parameters().insert( last, thisParm );
     940                    ++last;
     941                }
     942                for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
     943///      *assert = (*assert)->acceptMutator( *this );
     944                    inferredParams.push_back( *assert );
     945                }
     946                (*tyParm)->get_assertions().clear();
     947            }
     948            delete newObj;
     949            funcType->get_parameters().splice( last, inferredParams );
     950            addAdapters( funcType );
     951            mutateAll( funcType->get_returnVals(), *this );
     952            mutateAll( funcType->get_parameters(), *this );
     953 
     954            scopeTyVars = oldtyVars;
     955            return funcType;
     956        }
    1049957
    1050958////////////////////////////////////////// Pass3 ////////////////////////////////////////////////////
    1051959
    1052 template< typename DeclClass >
    1053 DeclClass*
    1054 Pass3::handleDecl( DeclClass *decl, Type *type )
    1055 {
    1056   TyVarMap oldtyVars = scopeTyVars;
    1057   makeTyVarMap( type, scopeTyVars );
    1058  
    1059   DeclClass *ret = static_cast< DeclClass* >( Mutator::mutate( decl ) );
    1060   ScrubTyVars::scrub( decl, scopeTyVars );
    1061 
    1062   scopeTyVars = oldtyVars;
    1063   return ret;
    1064 }
    1065 
    1066 ObjectDecl*
    1067 Pass3::mutate( ObjectDecl *objectDecl )
    1068 {
    1069   return handleDecl( objectDecl, objectDecl->get_type() );
    1070 }
    1071 
    1072 DeclarationWithType*
    1073 Pass3::mutate( FunctionDecl *functionDecl )
    1074 {
    1075   return handleDecl( functionDecl, functionDecl->get_functionType() );
    1076 }
    1077 
    1078 TypedefDecl*
    1079 Pass3::mutate( TypedefDecl *typedefDecl )
    1080 {
    1081   return handleDecl( typedefDecl, typedefDecl->get_base() );
    1082 }
    1083 
    1084 TypeDecl*
    1085 Pass3::mutate( TypeDecl *typeDecl )
    1086 {
     960        template< typename DeclClass >
     961        DeclClass *
     962        Pass3::handleDecl( DeclClass *decl, Type *type ) {
     963            TyVarMap oldtyVars = scopeTyVars;
     964            makeTyVarMap( type, scopeTyVars );
     965 
     966            DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
     967            ScrubTyVars::scrub( decl, scopeTyVars );
     968
     969            scopeTyVars = oldtyVars;
     970            return ret;
     971        }
     972
     973        ObjectDecl *
     974        Pass3::mutate( ObjectDecl *objectDecl ) {
     975            return handleDecl( objectDecl, objectDecl->get_type() );
     976        }
     977
     978        DeclarationWithType *
     979        Pass3::mutate( FunctionDecl *functionDecl ) {
     980            return handleDecl( functionDecl, functionDecl->get_functionType() );
     981        }
     982
     983        TypedefDecl *
     984        Pass3::mutate( TypedefDecl *typedefDecl ) {
     985            return handleDecl( typedefDecl, typedefDecl->get_base() );
     986        }
     987
     988        TypeDecl *
     989        Pass3::mutate( TypeDecl *typeDecl ) {
    1087990///   Initializer *init = 0;
    1088991///   std::list< Expression *> designators;
    1089992///   scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
    1090 ///   if( typeDecl->get_base() ) {
     993///   if ( typeDecl->get_base() ) {
    1091994///     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
    1092995///   }
    1093996///   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
    1094997
    1095   scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
    1096   return Mutator::mutate( typeDecl );
    1097 }
    1098 
    1099 Type*
    1100 Pass3::mutate( PointerType *pointerType )
    1101 {
    1102   TyVarMap oldtyVars = scopeTyVars;
    1103   makeTyVarMap( pointerType, scopeTyVars );
    1104  
    1105   Type* ret = Mutator::mutate( pointerType );
    1106  
    1107   scopeTyVars = oldtyVars;
    1108   return ret;
    1109 }
    1110 
    1111 Type*
    1112 Pass3::mutate( FunctionType *functionType )
    1113 {
    1114   TyVarMap oldtyVars = scopeTyVars;
    1115   makeTyVarMap( functionType, scopeTyVars );
    1116  
    1117   Type* ret = Mutator::mutate( functionType );
    1118  
    1119   scopeTyVars = oldtyVars;
    1120   return ret;
    1121 }
    1122 
    1123 Statement*
    1124 Pass3::mutate( DeclStmt *declStmt )
    1125 {
    1126   if( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl* >( declStmt->get_decl() ) ) {
    1127     if( isPolyVal( objectDecl->get_type(), scopeTyVars ) ) {
    1128       TypeInstType *typeInst = dynamic_cast< TypeInstType* >( objectDecl->get_type() );
    1129       assert( typeInst );
    1130       UntypedExpr *alloc = new UntypedExpr( new NameExpr( "alloca" ) );
    1131       alloc->get_args().push_back( new NameExpr( typeInst->get_name() ) );
    1132       UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
    1133       assign->get_args().push_back( new VariableExpr( objectDecl ) );
    1134       assign->get_args().push_back( alloc );
    1135       stmtsToAddAfter.push_back( new ExprStmt( noLabels, assign ) );
    1136     }
    1137   }
    1138   return Mutator::mutate( declStmt );
    1139 }
     998            scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
     999            return Mutator::mutate( typeDecl );
     1000        }
     1001
     1002        Type *
     1003        Pass3::mutate( PointerType *pointerType ) {
     1004            TyVarMap oldtyVars = scopeTyVars;
     1005            makeTyVarMap( pointerType, scopeTyVars );
     1006 
     1007            Type *ret = Mutator::mutate( pointerType );
     1008 
     1009            scopeTyVars = oldtyVars;
     1010            return ret;
     1011        }
     1012
     1013        Type *
     1014        Pass3::mutate( FunctionType *functionType ) {
     1015            TyVarMap oldtyVars = scopeTyVars;
     1016            makeTyVarMap( functionType, scopeTyVars );
     1017 
     1018            Type *ret = Mutator::mutate( functionType );
     1019 
     1020            scopeTyVars = oldtyVars;
     1021            return ret;
     1022        }
     1023
     1024        Statement *Pass3::mutate( DeclStmt *declStmt ) {
     1025            if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
     1026                if ( isPolyVal( objectDecl->get_type(), scopeTyVars ) ) {
     1027                    TypeInstType *typeInst = dynamic_cast< TypeInstType *>( objectDecl->get_type() );
     1028                    assert( typeInst );
     1029                    UntypedExpr *alloc = new UntypedExpr( new NameExpr( "alloca" ) );
     1030                    alloc->get_args().push_back( new NameExpr( typeInst->get_name() ) );
     1031                    UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
     1032                    assign->get_args().push_back( new VariableExpr( objectDecl ) );
     1033                    assign->get_args().push_back( alloc );
     1034                    stmtsToAddAfter.push_back( new ExprStmt( noLabels, assign ) );
     1035                }
     1036            }
     1037            return Mutator::mutate( declStmt );
     1038        }
    11401039   
    1141 } // anonymous namespace
     1040    } // anonymous namespace
    11421041
    11431042} // namespace GenPoly
  • translator/Parser/TypeData.cc

    r0b8cd72 r6c3744e  
    696696            } else {
    697697                switch ( ret ) {
     698                  case BasicType::LongLongSignedInt:    // PAB
     699                    ret = BasicType::LongLongUnsignedInt;
     700                    break;
     701                  case BasicType::LongSignedInt:
     702                    ret = BasicType::LongUnsignedInt;
     703                    break;
    698704                  case BasicType::SignedInt:
    699705                  case BasicType::ShortSignedInt:
     
    715721            } else {
    716722                switch ( ret ) {
     723                  case BasicType::LongLongSignedInt:    // PAB
     724                    ret = BasicType::LongLongUnsignedInt;
     725                    break;
    717726                  case BasicType::LongSignedInt:
    718727                    ret = BasicType::LongUnsignedInt;
  • translator/Parser/cfa.y

    r0b8cd72 r6c3744e  
    1010 * Created On       : Sat Sep  1 20:22:55 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Wed Jan  7 09:19:57 2015
    13  * Update Count     : 906
     12 * Last Modified On : Sat Jan 17 09:23:45 2015
     13 * Update Count     : 908
    1414 */
    1515
    16 /* This grammar is based on the ANSI99 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on the
    17    C grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS.  While parts
    18    have been copied, important changes have been made in all sections; these changes are sufficient to
     16/* This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on
     17   the C grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS.  While
     18   parts have been copied, important changes have been made in all sections; these changes are sufficient to
    1919   constitute a new grammar.  In particular, this grammar attempts to be more syntactically precise, i.e., it
    2020   parses less incorrect language syntax that must be subsequently rejected by semantic checks.  Nevertheless,
    21    there are still several semantic checks required and many are noted in the grammar. Finally, the grammar
    22    is extended with GCC and CFA language extensions. */
     21   there are still several semantic checks required and many are noted in the grammar. Finally, the grammar is
     22   extended with GCC and CFA language extensions. */
    2323
    2424/* Acknowledgments to Richard Bilson, Glen Ditchfield, and Rodolfo Gabriel Esteves who all helped when I got
    2525   stuck with the grammar. */
    2626
    27 /* The root language for this grammar is ANSI99 C. All of ANSI99 is parsed, except for:
     27/* The root language for this grammar is ANSI99/11 C. All of ANSI99/11 is parsed, except for:
    2828
    2929   1. designation with '=' (use ':' instead)
    3030
    31    Most of the syntactic extensions from ANSI90 to ANSI99 C are marked with the comment "ANSI99". This grammar
     31   Most of the syntactic extensions from ANSI90 to ANSI11 C are marked with the comment "C99/C11". This grammar
    3232   also has two levels of extensions. The first extensions cover most of the GCC C extensions, except for:
    3333
     
    4040   Cforall (CFA), which fixes several of C's outstanding problems and extends C with many modern language
    4141   concepts. All of the syntactic extensions for CFA C are marked with the comment "CFA". As noted above,
    42    there is one unreconcileable parsing problem between ANSI99 and CFA with respect to designators; this is
     42   there is one unreconcileable parsing problem between C99 and CFA with respect to designators; this is
    4343   discussed in detail before the "designation" grammar rule. */
    4444
     
    6767%token TYPEDEF
    6868%token AUTO EXTERN REGISTER STATIC
    69 %token INLINE                                           /* ANSI99 */
    70 %token FORTRAN                                          /* ANSI99, extension ISO/IEC 9899:1999 Section J.5.9(1) */
     69%token INLINE                                           /* C99 */
     70%token FORTRAN                                          /* C99, extension ISO/IEC 9899:1999 Section J.5.9(1) */
    7171%token CONST VOLATILE
    72 %token RESTRICT                                         /* ANSI99 */
     72%token RESTRICT                                         /* C99 */
    7373%token FORALL LVALUE                                    /* CFA */
    7474%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
    75 %token BOOL COMPLEX IMAGINARY                           /* ANSI99 */
     75%token BOOL COMPLEX IMAGINARY                           /* C99 */
    7676%token TYPEOF LABEL                                     /* GCC */
    7777%token ENUM STRUCT UNION
    7878%token TYPE FTYPE DTYPE CONTEXT                         /* CFA */
    7979%token SIZEOF
    80 %token ALIGNOF ATTRIBUTE EXTENSION                      /* GCC */
     80%token ATTRIBUTE EXTENSION                              /* GCC */
    8181%token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
    8282%token CHOOSE FALLTHRU TRY CATCH FINALLY THROW          /* CFA */
    83 %token ASM                                              /* ANSI99, extension ISO/IEC 9899:1999 Section J.5.10(1) */
     83%token ASM                                              /* C99, extension ISO/IEC 9899:1999 Section J.5.10(1) */
     84%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL /* C11 */
    8485
    8586/* names and constants: lexer differentiates between identifier and typedef names */
     
    362363                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::DecrPost), $1); }
    363364                /* GCC has priority: cast_expression */
    364         | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' /* ANSI99 */
     365        | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' /* C99 */
    365366                { $$ = 0; }
    366367        ;
     
    642643          push push
    643644          label_declaration_opt                         /* GCC, local labels */
    644           block_item_list pop '}'                       /* ANSI99, intermix declarations and statements */
     645          block_item_list pop '}'                       /* C99, intermix declarations and statements */
    645646                { $$ = new CompoundStmtNode( $5 ); }
    646647        ;
    647648
    648 block_item_list:                                        /* ANSI99 */
     649block_item_list:                                        /* C99 */
    649650        block_item
    650651        | block_item_list push block_item
     
    773774        comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt
    774775                                                { $$ = new ForCtlExprNode($1, $4, $6); }
    775         | declaration comma_expression_opt ';' comma_expression_opt /* ANSI99 */
     776        | declaration comma_expression_opt ';' comma_expression_opt /* C99 */
    776777                /* Like C++, the loop index can be declared local to the loop. */
    777778                                                { $$ = new ForCtlExprNode($1, $2, $4); }
     
    12441245        | STATIC
    12451246                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    1246         | INLINE                                        /* ANSI99 */
     1247        | INLINE                                        /* C99 */
    12471248                /* INLINE is essentially a storage class specifier for functions, and hence, belongs here. */
    12481249                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
    1249         | FORTRAN                                       /* ANSI99 */
     1250        | FORTRAN                                       /* C99 */
    12501251                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    12511252        ;
     
    12701271        | VOID
    12711272                { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    1272         | BOOL                                          /* ANSI99 */
     1273        | BOOL                                          /* C99 */
    12731274                { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    1274         | COMPLEX                                       /* ANSI99 */
     1275        | COMPLEX                                       /* C99 */
    12751276                { $$ = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
    1276         | IMAGINARY                                     /* ANSI99 */
     1277        | IMAGINARY                                     /* C99 */
    12771278                { $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
    12781279        ;
     
    16421643        ;
    16431644
    1644 /* There is an unreconcileable parsing problem between ANSI99 and CFA with respect to designators. The problem
     1645/* There is an unreconcileable parsing problem between C99 and CFA with respect to designators. The problem
    16451646   is use of '=' to separator the designator from the initializer value, as in:
    16461647
     
    16531654
    16541655designation:
    1655         designator_list ':'                             /* ANSI99, CFA uses ":" instead of "=" */
     1656        designator_list ':'                             /* C99, CFA uses ":" instead of "=" */
    16561657        | no_attr_identifier_or_typedef_name ':'        /* GCC, field name */
    16571658                                                        { $$ = new VarRefNode( $1 ); }
    16581659        ;
    16591660
    1660 designator_list:                                        /* ANSI99 */
     1661designator_list:                                        /* C99 */
    16611662        designator
    16621663        | designator_list designator                    { $$ = (ExpressionNode *)($1->set_link( $2 )); }
     
    16641665
    16651666designator:
    1666         '.' no_attr_identifier_or_typedef_name          /* ANSI99, field name */
     1667        '.' no_attr_identifier_or_typedef_name          /* C99, field name */
    16671668                                                        { $$ = new VarRefNode( $2 ); }
    1668         | '[' push assignment_expression pop ']'        /* ANSI99, single array element */
     1669        | '[' push assignment_expression pop ']'        /* C99, single array element */
    16691670                /* assignment_expression used instead of constant_expression because of shift/reduce conflicts
    16701671                   with tuple. */
     
    22572258
    22582259/* This pattern parses a declaration for a parameter variable or function prototype that is not redefining a
    2259    typedef name and allows the ANSI99 array options, which can only appear in a parameter list.  The pattern
     2260   typedef name and allows the C99 array options, which can only appear in a parameter list.  The pattern
    22602261   precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
    22612262   and functions versus pointers to arrays and functions. */
     
    23032304        int f( int foo ); // redefine typedef name in new scope
    23042305
    2305    and allows the ANSI99 array options, which can only appear in a parameter list.  In addition, the pattern
     2306   and allows the C99 array options, which can only appear in a parameter list.  In addition, the pattern
    23062307   handles the special meaning of parenthesis around a typedef name:
    23072308
     
    24202421        '[' push assignment_expression pop ']'
    24212422                { $$ = DeclarationNode::newArray( $3, 0, false ); }
    2422         | '[' push '*' pop ']'                          /* ANSI99 */
     2423        | '[' push '*' pop ']'                          /* C99 */
    24232424                { $$ = DeclarationNode::newVarArray( 0 ); }
    24242425        | multi_array_dimension '[' push assignment_expression pop ']'
    24252426                { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
    2426         | multi_array_dimension '[' push '*' pop ']'    /* ANSI99 */
     2427        | multi_array_dimension '[' push '*' pop ']'    /* C99 */
    24272428                { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
    24282429        ;
     
    24932494                { $$ = DeclarationNode::newArray( 0, 0, false ); }
    24942495        // multi_array_dimension handles the '[' '*' ']' case
    2495         | '[' push type_qualifier_list '*' pop ']'      /* remaining ANSI99 */
     2496        | '[' push type_qualifier_list '*' pop ']'      /* remaining C99 */
    24962497                { $$ = DeclarationNode::newVarArray( $3 ); }
    24972498        | '[' push type_qualifier_list pop ']'
     
    25512552
    25522553/* This pattern parses a new-style declaration for a parameter variable or function prototype that is either
    2553    an identifier or typedef name and allows the ANSI99 array options, which can only appear in a parameter
     2554   an identifier or typedef name and allows the C99 array options, which can only appear in a parameter
    25542555   list. */
    25552556
     
    26072608
    26082609new_array_parameter_1st_dimension:
    2609         '[' push type_qualifier_list '*' pop ']'        /* remaining ANSI99 */
     2610        '[' push type_qualifier_list '*' pop ']'        /* remaining C99 */
    26102611                { $$ = DeclarationNode::newVarArray( $3 ); }
    26112612        | '[' push type_qualifier_list assignment_expression pop ']'
  • translator/Parser/lex.l

    r0b8cd72 r6c3744e  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Wed Dec  3 13:37:52 2014
    13  * Update Count     : 317
     12 * Last Modified On : Sat Jan 17 09:15:03 2015
     13 * Update Count     : 318
    1414 */
    1515
     
    180180
    181181        /* keywords */
     182_Alignas                { KEYWORD_RETURN(ALIGNAS); }    // C11
     183_Alignof                { KEYWORD_RETURN(ALIGNOF); }    // C11
    182184__alignof               { KEYWORD_RETURN(ALIGNOF); }    // GCC
    183185__alignof__             { KEYWORD_RETURN(ALIGNOF); }    // GCC
     
    185187__asm                   { KEYWORD_RETURN(ASM); }        // GCC
    186188__asm__                 { KEYWORD_RETURN(ASM); }        // GCC
     189_Atomic                 { KEYWORD_RETURN(ATOMIC); }     // C11
    187190__attribute             { KEYWORD_RETURN(ATTRIBUTE); }  // GCC
    188191__attribute__           { KEYWORD_RETURN(ATTRIBUTE); }  // GCC
     
    217220fortran                 { KEYWORD_RETURN(FORTRAN); }
    218221ftype                   { KEYWORD_RETURN(FTYPE); }      // CFA
     222_Generic                { KEYWORD_RETURN(GENERIC); }    // C11
    219223goto                    { KEYWORD_RETURN(GOTO); }
    220224if                      { KEYWORD_RETURN(IF); }
     
    229233long                    { KEYWORD_RETURN(LONG); }
    230234lvalue                  { KEYWORD_RETURN(LVALUE); }     // CFA
     235_Noreturn               { KEYWORD_RETURN(NORETURN); }   // C11
    231236register                { KEYWORD_RETURN(REGISTER); }
    232237restrict                { KEYWORD_RETURN(RESTRICT); }   // C99
     
    240245sizeof                  { KEYWORD_RETURN(SIZEOF); }
    241246static                  { KEYWORD_RETURN(STATIC); }
     247_Static_assert          { KEYWORD_RETURN(STATICASSERT); } // C11
    242248struct                  { KEYWORD_RETURN(STRUCT); }
    243249switch                  { KEYWORD_RETURN(SWITCH); }
     250_Thread_local           { KEYWORD_RETURN(THREADLOCAL); } // C11
    244251throw                   { KEYWORD_RETURN(THROW); }      // CFA
    245252try                     { KEYWORD_RETURN(TRY); }        // CFA
  • translator/ResolvExpr/Resolver.cc

    r0b8cd72 r6c3744e  
    246246            singleInit->set_value( newExpr );
    247247        } // if
    248         singleInit->get_value()->accept( *this );
     248//      singleInit->get_value()->accept( *this );
    249249    }
    250250
    251251    void Resolver::visit( ListInit *listInit ) {
    252         // no cast necessary
     252        if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) {
     253            initContext = at->get_base();
     254            Visitor::visit( listInit );
     255        } else if ( StructInstType *st = dynamic_cast<StructInstType*>(initContext) ) {
     256            StructDecl *baseStruct = st->get_baseStruct();
     257            std::list<Declaration *>::iterator iter1( baseStruct->get_members().begin() );
     258            std::list<Initializer *>::iterator iter2( listInit->begin_initializers() );
     259            for ( ; iter1 != baseStruct->get_members().end() && iter2 != listInit->end_initializers() ; ++iter1, ++iter2 ) {
     260                DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *iter1 );
     261                initContext = dt->get_type();
     262                (*iter2)->accept( *this );
     263            }
     264        } else if ( UnionInstType *st = dynamic_cast<UnionInstType*>(initContext) ) {
     265            DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *st->get_baseUnion()->get_members().begin() );
     266            initContext = dt->get_type();
     267            (*listInit->begin_initializers())->accept( *this );
     268        } // if
    253269    }
    254270} // namespace ResolvExpr
  • translator/SymTab/Validate.cc

    r0b8cd72 r6c3744e  
    468468    template< typename OutputIterator >
    469469    void makeScalarAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, OutputIterator out ) {
    470         ObjectDecl *obj = dynamic_cast<ObjectDecl *>( member ); // PAB: unnamed bit fields are not copied
     470        ObjectDecl *obj = dynamic_cast<ObjectDecl *>( member );
     471        // unnamed bit fields are not copied as they cannot be accessed
    471472        if ( obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL ) return;
    472473
  • translator/SynTree/Makefile

    r0b8cd72 r6c3744e  
    22CXXFLAGS=-g -Wall #-Wno-unused
    33
    4 SRCS:=Type.cc Constant.cc Expression.cc Statement.cc CodeGenVisitor.cc translate.cc
     4SRCS:=Type.cc Constant.cc Expression.cc Statement.cc CodeGenVisitor.cc
    55OBJECTS:=$(SRCS:.cc=.o)
    66DEPS:=$(SRCS:.cc=.d)
  • translator/examples/includes.c

    r0b8cd72 r6c3744e  
    1 #if 0
     1#if 1
     2//#include <aio.h>              // FAILS -- includes locale.h
     3#include <aliases.h>
    24#include <alloca.h>
     5#include <ansidecl.h>
     6#include <ar.h>
     7//#include <argp.h>             // FAILS -- includes locale.h
     8//#include <argz.h>             // FAILS -- includes locale.h
    39#include <assert.h>
     10#include <bfd.h>                // contains structure field "type"
    411#include <complex.h>
    5 //#include <ctype.h>        // FAILS -- includes locale.h
     12//#include <ctype.h>            // FAILS -- includes locale.h
    613#include <errno.h>
    714#include <fenv.h>
     
    1017#include <iso646.h>
    1118#include <limits.h>
    12 //#include <locale.h>       // FAILS -- "no reasonable alternatives for applying ... Name: ?+? ..."
    13 #include <math.h>
     19//#include <locale.h>           // FAILS -- "no reasonable alternatives for applying ... Name: ?+? ..."
     20#include <math.h>               // contains structure field "type"
    1421#include <setjmp.h>
    1522#include <signal.h>
     
    1926#include <stdlib.h>
    2027#include <stdio.h>
    21 //#include <string.h>       // FAILS -- includes locale.h
     28//#include <string.h>           // FAILS -- includes locale.h
    2229#include <tgmath.h>
    23 //#include <time.h>         // FAILS -- includes locale.h
     30//#include <time.h>             // FAILS -- includes locale.h
    2431#include <unistd.h>
    25 //#include <wchar.h>        // FAILS -- includes locale.h
    26 //#include <wctype.h>       // FAILS -- includes locale.h
     32//#include <wchar.h>            // FAILS -- includes locale.h
     33//#include <wctype.h>           // FAILS -- includes locale.h
    2734#include <curses.h>
    2835#else
    29 #include <aio.h>
    3036#endif // 0
    3137
Note: See TracChangeset for help on using the changeset viewer.