Changeset e4d829b


Ignore:
Timestamp:
Jun 20, 2017, 1:19:53 PM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
579263a
Parents:
c6d2e93
git-author:
Rob Schluntz <rschlunt@…> (06/20/17 13:16:13)
git-committer:
Rob Schluntz <rschlunt@…> (06/20/17 13:19:53)
Message:

major effort on designations, works in many cases

Location:
src
Files:
2 added
24 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    rc6d2e93 re4d829b  
    298298        }
    299299
    300         void CodeGenerator::printDesignators( std::list< Expression * > & designators ) {
    301                 typedef std::list< Expression * > DesignatorList;
     300        void CodeGenerator::visit( Designation * designation ) {
     301                std::list< Expression * > designators = designation->get_designators();
    302302                if ( designators.size() == 0 ) return;
    303                 for ( DesignatorList::iterator iter = designators.begin(); iter != designators.end(); ++iter ) {
    304                         if ( dynamic_cast< NameExpr * >( *iter ) ) {
    305                                 // if expression is a name, then initializing aggregate member
     303                for ( Expression * des : designators ) {
     304                        if ( dynamic_cast< ConstantExpr * >( des ) ) {
     305                                // if expression is a ConstantExpr, then initializing array element
     306                                output << "[";
     307                                des->accept( *this );
     308                                output << "]";
     309                        } else {
     310                                // if not a ConstantExpr, it has to be a NameExpr or VariableExpr, initializing aggregate member
    306311                                output << ".";
    307                                 (*iter)->accept( *this );
    308                         } else {
    309                                 // if not a simple name, it has to be a constant expression, i.e. an array designator
    310                                 output << "[";
    311                                 (*iter)->accept( *this );
    312                                 output << "]";
     312                                des->accept( *this );
    313313                        } // if
    314314                } // for
     
    317317
    318318        void CodeGenerator::visit( SingleInit * init ) {
    319                 printDesignators( init->get_designators() );
    320319                init->get_value()->accept( *this );
    321320        }
    322321
    323322        void CodeGenerator::visit( ListInit * init ) {
    324                 printDesignators( init->get_designators() );
     323                auto initBegin = init->begin();
     324                auto initEnd = init->end();
     325                auto desigBegin = init->get_designations().begin();
     326                auto desigEnd = init->get_designations().end();
     327
    325328                output << "{ ";
    326                 genCommaList( init->begin(), init->end() );
     329                for ( ; initBegin != initEnd && desigBegin != desigEnd; ) {
     330                        (*desigBegin)->accept( *this );
     331                        (*initBegin)->accept( *this );
     332                        ++initBegin, ++desigBegin;
     333                        if ( initBegin != initEnd ) {
     334                                output << ", ";
     335                        }
     336                }
    327337                output << " }";
     338                assertf( initBegin == initEnd && desigBegin == desigEnd, "Initializers and designators not the same length. %s", toString( init ).c_str() );
    328339        }
    329340
     
    726737
    727738        void CodeGenerator::visit( TypeExpr * typeExpr ) {
    728                 assertf( ! genC, "TypeExpr should not reach code generation." );
    729                 output<< genType( typeExpr->get_type(), "", pretty, genC );
     739                // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
     740                // assertf( ! genC, "TypeExpr should not reach code generation." );
     741                if ( ! genC ) {
     742                        output<< genType( typeExpr->get_type(), "", pretty, genC );
     743                }
    730744        }
    731745
  • src/CodeGen/CodeGenerator.h

    rc6d2e93 re4d829b  
    4747
    4848                //*** Initializer
     49                virtual void visit( Designation * );
    4950                virtual void visit( SingleInit * );
    5051                virtual void visit( ListInit * );
     
    136137                bool lineMarks = false;
    137138
    138                 void printDesignators( std::list< Expression * > & );
    139139                void handleStorageClass( DeclarationWithType *decl );
    140140                void handleAggregate( AggregateDecl *aggDecl, const std::string & kind );
  • src/Common/utility.h

    rc6d2e93 re4d829b  
    305305// for ( val : group_iterate( container1, container2, ... ) ) {}
    306306// syntax to have a for each that iterates multiple containers of the same length
    307 // TODO: update to use variadic arguments
     307// TODO: update to use variadic arguments, perfect forwarding
    308308
    309309template< typename T1, typename T2 >
  • src/InitTweak/FixInit.cc

    rc6d2e93 re4d829b  
    726726                                                // static bool __objName_uninitialized = true
    727727                                                BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
    728                                                 SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
     728                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ) );
    729729                                                ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
    730730                                                isUninitializedVar->fixUniqueId();
  • src/InitTweak/InitTweak.cc

    rc6d2e93 re4d829b  
    1414                public:
    1515                        bool hasDesignations = false;
    16                         template<typename Init>
    17                         void handleInit( Init * init ) {
    18                                 if ( ! init->get_designators().empty() ) hasDesignations = true;
    19                                 else Visitor::visit( init );
    20                         }
    21                         virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
    22                         virtual void visit( ListInit * listInit ) { handleInit( listInit); }
     16                        virtual void visit( Designation * des ) {
     17                                if ( ! des->get_designators().empty() ) hasDesignations = true;
     18                                else Visitor::visit( des );
     19                        }
    2320                };
    2421
  • src/MakeLibCfa.cc

    rc6d2e93 re4d829b  
    9292                assert( ! objDecl->get_init() );
    9393                std::list< Expression* > noDesignators;
    94                 objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), noDesignators, false ) ); // cannot be constructed
     94                objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), false ) ); // cannot be constructed
    9595                newDecls.push_back( objDecl );
    9696        }
  • src/Makefile.in

    rc6d2e93 re4d829b  
    161161        ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT) \
    162162        ResolvExpr/driver_cfa_cpp-TypeEnvironment.$(OBJEXT) \
     163        ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT) \
    163164        SymTab/driver_cfa_cpp-Indexer.$(OBJEXT) \
    164165        SymTab/driver_cfa_cpp-Mangler.$(OBJEXT) \
     
    414415        ResolvExpr/RenameVars.cc ResolvExpr/FindOpenVars.cc \
    415416        ResolvExpr/PolyCost.cc ResolvExpr/Occurs.cc \
    416         ResolvExpr/TypeEnvironment.cc SymTab/Indexer.cc \
    417         SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \
    418         SymTab/ImplementationType.cc SymTab/TypeEquality.cc \
    419         SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \
    420         SynTree/BasicType.cc SynTree/PointerType.cc \
    421         SynTree/ArrayType.cc SynTree/FunctionType.cc \
    422         SynTree/ReferenceToType.cc SynTree/TupleType.cc \
    423         SynTree/TypeofType.cc SynTree/AttrType.cc \
     417        ResolvExpr/TypeEnvironment.cc ResolvExpr/CurrentObject.cc \
     418        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
     419        SymTab/FixFunction.cc SymTab/ImplementationType.cc \
     420        SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \
     421        SynTree/VoidType.cc SynTree/BasicType.cc \
     422        SynTree/PointerType.cc SynTree/ArrayType.cc \
     423        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
     424        SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
    424425        SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
    425426        SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
     
    721722        ResolvExpr/$(am__dirstamp) \
    722723        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     724ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT):  \
     725        ResolvExpr/$(am__dirstamp) \
     726        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    723727SymTab/$(am__dirstamp):
    724728        @$(MKDIR_P) SymTab
     
    890894        -rm -f ResolvExpr/driver_cfa_cpp-CommonType.$(OBJEXT)
    891895        -rm -f ResolvExpr/driver_cfa_cpp-ConversionCost.$(OBJEXT)
     896        -rm -f ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT)
    892897        -rm -f ResolvExpr/driver_cfa_cpp-FindOpenVars.$(OBJEXT)
    893898        -rm -f ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT)
     
    10021007@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CommonType.Po@am__quote@
    10031008@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ConversionCost.Po@am__quote@
     1009@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po@am__quote@
    10041010@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-FindOpenVars.Po@am__quote@
    10051011@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Occurs.Po@am__quote@
     
    19431949@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-TypeEnvironment.obj `if test -f 'ResolvExpr/TypeEnvironment.cc'; then $(CYGPATH_W) 'ResolvExpr/TypeEnvironment.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/TypeEnvironment.cc'; fi`
    19441950
     1951ResolvExpr/driver_cfa_cpp-CurrentObject.o: ResolvExpr/CurrentObject.cc
     1952@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.o -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc
     1953@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po
     1954@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.o' libtool=no @AMDEPBACKSLASH@
     1955@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1956@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc
     1957
     1958ResolvExpr/driver_cfa_cpp-CurrentObject.obj: ResolvExpr/CurrentObject.cc
     1959@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.obj -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi`
     1960@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po
     1961@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.obj' libtool=no @AMDEPBACKSLASH@
     1962@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1963@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi`
     1964
    19451965SymTab/driver_cfa_cpp-Indexer.o: SymTab/Indexer.cc
    19461966@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-Indexer.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Tpo -c -o SymTab/driver_cfa_cpp-Indexer.o `test -f 'SymTab/Indexer.cc' || echo '$(srcdir)/'`SymTab/Indexer.cc
  • src/Parser/InitializerNode.cc

    rc6d2e93 re4d829b  
    7474
    7575        InitializerNode *moreInit;
    76         if  ( get_next() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) != 0) )
     76        if ( (moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) ) {
    7777                moreInit->printOneLine( os );
     78        }
    7879}
    7980
    8081Initializer *InitializerNode::build() const {
    8182        if ( aggregate ) {
     83                // steal designators from children
     84                std::list< Designation * > designlist;
     85                InitializerNode * child = next_init();
     86                for ( ; child != nullptr; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
     87                        std::list< Expression * > desList;
     88                        buildList< Expression, ExpressionNode >( child->designator, desList );
     89                        designlist.push_back( new Designation( desList ) );
     90                } // for
    8291                std::list< Initializer * > initlist;
    8392                buildList< Initializer, InitializerNode >( next_init(), initlist );
    84 
    85                 std::list< Expression * > designlist;
    86 
    87                 if ( designator != 0 ) {
    88                         buildList< Expression, ExpressionNode >( designator, designlist );
    89                 } // if
    90 
    9193                return new ListInit( initlist, designlist, maybeConstructed );
    9294        } else {
    93                 std::list< Expression * > designators;
    94 
    95                 if ( designator != 0 )
    96                         buildList< Expression, ExpressionNode >( designator, designators );
    97 
    98                 if ( get_expression() != 0)
    99                         return new SingleInit( maybeBuild< Expression >( get_expression() ), designators, maybeConstructed );
     95                if ( get_expression() != 0) {
     96                        return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
     97                }
    10098        } // if
    101 
    10299        return 0;
    103100}
  • src/Parser/TypeData.cc

    rc6d2e93 re4d829b  
    760760                if ( cur->has_enumeratorValue() ) {
    761761                        ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
    762                         member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) );
     762                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
    763763                } // if
    764764        } // for
  • src/ResolvExpr/AlternativeFinder.cc

    rc6d2e93 re4d829b  
    604604//          )
    605605                SymTab::Indexer decls( indexer );
    606                 PRINT(
    607                         std::cerr << "============= original indexer" << std::endl;
    608                         indexer.print( std::cerr );
    609                         std::cerr << "============= new indexer" << std::endl;
    610                         decls.print( std::cerr );
    611                 )
     606                // PRINT(
     607                //      std::cerr << "============= original indexer" << std::endl;
     608                //      indexer.print( std::cerr );
     609                //      std::cerr << "============= new indexer" << std::endl;
     610                //      decls.print( std::cerr );
     611                // )
    612612                addToIndexer( have, decls );
    613613                AssertionSet newNeed;
     
    11821182        }
    11831183
     1184        void AlternativeFinder::visit( UntypedInitExpr *initExpr ) {
     1185                AlternativeFinder finder( indexer, env );
     1186                finder.findWithAdjustment( initExpr->get_expr() );
     1187                // handle each option like a cast -- should probably push this info into AltFinder as a kind of expression, both to keep common code close and to have less 'reach-in', but more 'push-in'
     1188                AltList candidates;
     1189                std::cerr << "untyped init expr: " << initExpr << std::endl;
     1190                // O(N^2) checks of d-types with e-types
     1191                for ( Alternative & alt : finder.get_alternatives() ) {
     1192                        for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
     1193                                AssertionSet needAssertions, haveAssertions;
     1194                                OpenVarSet openVars;
     1195                                std::cerr << "  " << initAlt.type << " " << initAlt.designation << std::endl;
     1196                                // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
     1197                                // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
     1198                                // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
     1199                                // to.
     1200                                int discardedValues = alt.expr->get_result()->size() - initAlt.type->size();
     1201                                if ( discardedValues < 0 ) continue;
     1202                                // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
     1203                                // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
     1204                                // unification run for side-effects
     1205                                unify( initAlt.type, alt.expr->get_result(), alt.env, needAssertions, haveAssertions, openVars, indexer );
     1206
     1207                                Cost thisCost = castCost( alt.expr->get_result(), initAlt.type, indexer, alt.env );
     1208                                if ( thisCost != Cost::infinity ) {
     1209                                        // count one safe conversion for each value that is thrown away
     1210                                        thisCost += Cost( 0, 0, discardedValues );
     1211                                        candidates.push_back( Alternative( new InitExpr( alt.expr->clone(), initAlt.type->clone(), initAlt.designation->clone() ), alt.env, alt.cost, thisCost ) );
     1212                                }
     1213                        }
     1214                }
     1215
     1216                // findMinCost selects the alternatives with the lowest "cost" members, but has the side effect of copying the
     1217                // cvtCost member to the cost member (since the old cost is now irrelevant).  Thus, calling findMinCost twice
     1218                // selects first based on argument cost, then on conversion cost.
     1219                AltList minArgCost;
     1220                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( minArgCost ) );
     1221                findMinCost( minArgCost.begin(), minArgCost.end(), std::back_inserter( alternatives ) );
     1222        }
    11841223} // namespace ResolvExpr
    11851224
  • src/ResolvExpr/AlternativeFinder.h

    rc6d2e93 re4d829b  
    7373                virtual void visit( UniqueExpr *unqExpr );
    7474                virtual void visit( StmtExpr *stmtExpr );
     75                virtual void visit( UntypedInitExpr *initExpr );
    7576                /// Runs a new alternative finder on each element in [begin, end)
    7677                /// and writes each alternative finder to out.
  • src/ResolvExpr/Resolver.cc

    rc6d2e93 re4d829b  
    1414//
    1515
     16#include <iostream>
     17
     18#include "Alternative.h"
     19#include "AlternativeFinder.h"
     20#include "CurrentObject.h"
     21#include "RenameVars.h"
    1622#include "Resolver.h"
    17 #include "AlternativeFinder.h"
    18 #include "Alternative.h"
    19 #include "RenameVars.h"
    2023#include "ResolveTypeof.h"
    2124#include "typeops.h"
     25
     26#include "SynTree/Expression.h"
     27#include "SynTree/Initializer.h"
    2228#include "SynTree/Statement.h"
    2329#include "SynTree/Type.h"
    24 #include "SynTree/Expression.h"
    25 #include "SynTree/Initializer.h"
     30
     31#include "SymTab/Autogen.h"
    2632#include "SymTab/Indexer.h"
    27 #include "SymTab/Autogen.h"
     33
    2834#include "Common/utility.h"
     35
    2936#include "InitTweak/InitTweak.h"
    3037
    31 #include <iostream>
    3238using namespace std;
    3339
     
    3945                        if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
    4046                                functionReturn = res->functionReturn;
    41                                 initContext = res->initContext;
     47                                currentObject = res->currentObject;
    4248                                inEnumDecl = res->inEnumDecl;
    4349                        }
     
    7985
    8086                Type * functionReturn = nullptr;
    81                 Type *initContext = nullptr;
     87                CurrentObject currentObject = nullptr;
    8288                bool inEnumDecl = false;
    8389        };
     
    186192                // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
    187193                // the RHS.
    188                 Type *temp = initContext;
    189                 initContext = new_type;
    190                 if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
     194                ValueGuard<CurrentObject> temp( currentObject );
     195                currentObject = CurrentObject( objectDecl->get_type() );
     196                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
    191197                        // enumerator initializers should not use the enum type to initialize, since
    192198                        // the enum type is still incomplete at this point. Use signed int instead.
    193                         initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
     199                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
    194200                }
    195201                Parent::visit( objectDecl );
    196                 if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
     202                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
    197203                        // delete newly created signed int type
    198                         delete initContext;
    199                 }
    200                 initContext = temp;
     204                        // delete currentObject.getType();
     205                }
    201206        }
    202207
     
    315320
    316321        void Resolver::visit( SwitchStmt *switchStmt ) {
    317                 ValueGuard< Type * > oldInitContext( initContext );
     322                ValueGuard< CurrentObject > oldCurrentObject( currentObject );
    318323                Expression *newExpr;
    319324                newExpr = findIntegralExpression( switchStmt->get_condition(), *this );
     
    321326                switchStmt->set_condition( newExpr );
    322327
    323                 initContext = newExpr->get_result();
     328                currentObject = CurrentObject( newExpr->get_result() );
    324329                Parent::visit( switchStmt );
    325330        }
     
    327332        void Resolver::visit( CaseStmt *caseStmt ) {
    328333                if ( caseStmt->get_condition() ) {
    329                         assert( initContext );
    330                         CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initContext->clone() );
     334                        std::list< InitAlternative > initAlts = currentObject.getOptions();
     335                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
     336                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
    331337                        Expression * newExpr = findSingleExpression( castExpr, *this );
    332338                        castExpr = safe_dynamic_cast< CastExpr * >( newExpr );
     
    369375        }
    370376
     377        template< typename Aggr >
     378        void lookupDesignation( Aggr * aggr, const std::list< Expression > & designators ) {
     379
     380        }
     381
    371382        void Resolver::visit( SingleInit *singleInit ) {
    372                 if ( singleInit->get_value() ) {
    373                         // // find all the d's
    374                         // std::list<Expression *> &designators = singleInit->get_designators();
    375                         // std::list<Type *> types1{ initContext }, types2;
    376                         // for ( Expression * expr: designators ) {
    377                         //      cerr << expr << endl;
    378                         //      if ( NameExpr * nexpr = dynamic_cast<NameExpr *>( expr ) ) {
    379                         //              for ( Type * type: types1 ) {
    380                         //                      cerr << type << endl;
    381                         //                      ReferenceToType * fred = dynamic_cast<ReferenceToType *>(type);
    382                         //                      std::list<Declaration *> members;
    383                         //                      if ( fred ) {
    384                         //                              fred->lookup( nexpr->get_name(), members ); // concatenate identical field name
    385                         //                              for ( Declaration * mem: members ) {
    386                         //                                      if ( DeclarationWithType * dwt = dynamic_cast<DeclarationWithType *>(mem) ) {
    387                         //                                              types2.push_back( dwt->get_type() );
    388                         //                                      } // if
    389                         //                              } // for
    390                         //                      } // if
    391                         //              } // for
    392                         //              types1 = types2;
    393                         //              types2.clear();
    394                         //      } // if
    395                         // } // for
    396                         // // for ( Type * type: types1 ) {
    397                         // //   cerr << type << endl;
    398                         // // } // for
    399 
    400                         // // O(N^2) checks of d-types with f-types
    401                         // // find the minimum cost
    402                         CastExpr *castExpr = new CastExpr( singleInit->get_value(), initContext->clone() );
    403                         Expression *newExpr = findSingleExpression( castExpr, *this );
    404                         delete castExpr;
    405                         singleInit->set_value( newExpr );
    406 
    407                         // check if initializing type is char[]
    408                         if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
    409                                 if ( isCharType( at->get_base() ) ) {
    410                                         // check if the resolved type is char *
    411                                         if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
    412                                                 if ( isCharType( pt->get_base() ) ) {
    413                                                         // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
    414                                                         CastExpr *ce = dynamic_cast< CastExpr * >( newExpr );
    415                                                         singleInit->set_value( ce->get_arg() );
    416                                                         ce->set_arg( NULL );
    417                                                         delete ce;
    418                                                 }
    419                                         }
    420                                 }
    421                         }
    422                 } // if
    423         }
    424 
    425         template< typename AggrInst >
    426         TypeSubstitution makeGenericSubstitutuion( AggrInst * inst ) {
    427                 assert( inst );
    428                 assert( inst->get_baseParameters() );
    429                 std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
    430                 std::list< Expression * > typeSubs = inst->get_parameters();
    431                 TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
    432                 return subs;
    433         }
    434 
    435         ReferenceToType * isStructOrUnion( Type * type ) {
    436                 if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) {
    437                         return sit;
    438                 } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) {
    439                         return uit;
    440                 }
    441                 return nullptr;
    442         }
    443 
    444         void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) {
    445                 DeclarationWithType * dt = dynamic_cast< DeclarationWithType * >( dcl );
    446                 assert( dt );
    447                 // need to substitute for generic types, so that casts are to concrete types
    448                 initContext = dt->get_type()->clone();
    449                 sub.apply( initContext );
    450 
    451                 try {
    452                         if ( init == initEnd ) return; // stop when there are no more initializers
    453                         (*init)->accept( *this );
    454                         ++init; // made it past an initializer
    455                 } catch( SemanticError & ) {
    456                         // need to delve deeper, if you can
    457                         if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
    458                                 resolveAggrInit( type, init, initEnd );
    459                         } else {
    460                                 // member is not an aggregate type, so can't go any deeper
    461 
    462                                 // might need to rethink what is being thrown
    463                                 throw;
    464                         } // if
    465                 }
    466         }
    467 
    468         void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) {
    469                 if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) {
    470                         TypeSubstitution sub = makeGenericSubstitutuion( sit );
    471                         StructDecl * st = sit->get_baseStruct();
    472                         if(st->get_members().empty()) return;
    473                         // want to resolve each initializer to the members of the struct,
    474                         // but if there are more initializers than members we should stop
    475                         list< Declaration * >::iterator it = st->get_members().begin();
    476                         for ( ; it != st->get_members().end(); ++it) {
    477                                 resolveSingleAggrInit( *it, init, initEnd, sub );
    478                         }
    479                 } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) {
    480                         TypeSubstitution sub = makeGenericSubstitutuion( uit );
    481                         UnionDecl * un = uit->get_baseUnion();
    482                         if(un->get_members().empty()) return;
    483                         // only resolve to the first member of a union
    484                         resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub );
    485                 } // if
    486         }
     383                UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
     384                Expression * newExpr = findSingleExpression( untyped, *this );
     385                InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
     386                singleInit->set_value( new CastExpr( initExpr->get_expr()->clone(), initExpr->get_result()->clone() ) );
     387                currentObject.setNext( initExpr->get_designation() );
     388                currentObject.increment();
     389                delete initExpr;
     390
     391                // // check if initializing type is char[]
     392                // if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
     393                //      if ( isCharType( at->get_base() ) ) {
     394                //              // check if the resolved type is char *
     395                //              if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
     396                //                      if ( isCharType( pt->get_base() ) ) {
     397                //                              // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
     398                //                              CastExpr *ce = dynamic_cast< CastExpr * >( newExpr );
     399                //                              singleInit->set_value( ce->get_arg() );
     400                //                              ce->set_arg( NULL );
     401                //                              delete ce;
     402                //                      }
     403                //              }
     404                //      }
     405                // }
     406        }
     407
     408        // template< typename AggrInst >
     409        // TypeSubstitution makeGenericSubstitution( AggrInst * inst ) {
     410        //      assert( inst );
     411        //      assert( inst->get_baseParameters() );
     412        //      std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
     413        //      std::list< Expression * > typeSubs = inst->get_parameters();
     414        //      TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
     415        //      return subs;
     416        // }
     417
     418        // ReferenceToType * isStructOrUnion( Type * type ) {
     419        //      if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) {
     420        //              return sit;
     421        //      } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) {
     422        //              return uit;
     423        //      }
     424        //      return nullptr;
     425        // }
     426
     427        // void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) {
     428        //      ObjectDecl * obj = dynamic_cast< ObjectDecl * >( dcl );
     429        //      assert( obj );
     430        //      // need to substitute for generic types, so that casts are to concrete types
     431        //      currentObject = obj->clone();  // xxx - delete this
     432        //      sub.apply( currentObject );
     433
     434        //      try {
     435        //              if ( init == initEnd ) return; // stop when there are no more initializers
     436        //              (*init)->accept( *this );
     437        //              ++init; // made it past an initializer
     438        //      } catch( SemanticError & ) {
     439        //              // need to delve deeper, if you can
     440        //              if ( ReferenceToType * type = isStructOrUnion( currentObject->get_type() ) ) {
     441        //                      resolveAggrInit( type, init, initEnd );
     442        //              } else {
     443        //                      // member is not an aggregate type, so can't go any deeper
     444
     445        //                      // might need to rethink what is being thrown
     446        //                      throw;
     447        //              } // if
     448        //      }
     449        // }
     450
     451        // void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) {
     452        //      if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) {
     453        //              TypeSubstitution sub = makeGenericSubstitution( sit );
     454        //              StructDecl * st = sit->get_baseStruct();
     455        //              if(st->get_members().empty()) return;
     456        //              // want to resolve each initializer to the members of the struct,
     457        //              // but if there are more initializers than members we should stop
     458        //              list< Declaration * >::iterator it = st->get_members().begin();
     459        //              for ( ; it != st->get_members().end(); ++it) {
     460        //                      resolveSingleAggrInit( *it, init, initEnd, sub );
     461        //              }
     462        //      } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) {
     463        //              TypeSubstitution sub = makeGenericSubstitution( uit );
     464        //              UnionDecl * un = uit->get_baseUnion();
     465        //              if(un->get_members().empty()) return;
     466        //              // only resolve to the first member of a union
     467        //              resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub );
     468        //      } // if
     469        // }
    487470
    488471        void Resolver::visit( ListInit * listInit ) {
    489                 InitIterator iter = listInit->begin();
    490                 InitIterator end = listInit->end();
    491 
    492                 if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
    493                         // resolve each member to the base type of the array
    494                         for ( ; iter != end; ++iter ) {
    495                                 initContext = at->get_base();
    496                                 (*iter)->accept( *this );
    497                         } // for
    498                 } else if ( TupleType * tt = dynamic_cast< TupleType * > ( initContext ) ) {
    499                         for ( Type * t : *tt ) {
    500                                 if ( iter == end ) break;
    501                                 initContext = t;
    502                                 (*iter++)->accept( *this );
    503                         }
    504                 } else if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
    505                         resolveAggrInit( type, iter, end );
    506                 } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
    507                         Type * base = tt->get_baseType()->get_base();
    508                         if ( base ) {
    509                                 // know the implementation type, so try using that as the initContext
    510                                 initContext = base;
    511                                 visit( listInit );
    512                         } else {
    513                                 // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
    514                                 Parent::visit( listInit );
    515                         }
    516                 } else {
    517                         assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
    518                                 || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) || dynamic_cast < EnumInstType * > ( initContext ) );
    519                         // basic types are handled here
    520                         Parent::visit( listInit );
    521                 }
    522 
    523 #if 0
    524                 if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) {
    525                         std::list<Initializer *>::iterator iter( listInit->begin_initializers() );
    526                         for ( ; iter != listInit->end_initializers(); ++iter ) {
    527                                 initContext = at->get_base();
    528                                 (*iter)->accept( *this );
    529                         } // for
    530                 } else if ( StructInstType *st = dynamic_cast<StructInstType*>(initContext) ) {
    531                         StructDecl *baseStruct = st->get_baseStruct();
    532                         std::list<Declaration *>::iterator iter1( baseStruct->get_members().begin() );
    533                         std::list<Initializer *>::iterator iter2( listInit->begin_initializers() );
    534                         for ( ; iter1 != baseStruct->get_members().end() && iter2 != listInit->end_initializers(); ++iter2 ) {
    535                                 if ( (*iter2)->get_designators().empty() ) {
    536                                         DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *iter1 );
    537                                         initContext = dt->get_type();
    538                                         (*iter2)->accept( *this );
    539                                         ++iter1;
    540                                 } else {
    541                                         StructDecl *st = baseStruct;
    542                                         iter1 = st->get_members().begin();
    543                                         std::list<Expression *>::iterator iter3( (*iter2)->get_designators().begin() );
    544                                         for ( ; iter3 != (*iter2)->get_designators().end(); ++iter3 ) {
    545                                                 NameExpr *key = dynamic_cast<NameExpr *>( *iter3 );
    546                                                 assert( key );
    547                                                 for ( ; iter1 != st->get_members().end(); ++iter1 ) {
    548                                                         if ( key->get_name() == (*iter1)->get_name() ) {
    549                                                                 (*iter1)->print( cout );
    550                                                                 cout << key->get_name() << endl;
    551                                                                 ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
    552                                                                 assert( fred );
    553                                                                 StructInstType *mary = dynamic_cast<StructInstType*>( fred->get_type() );
    554                                                                 assert( mary );
    555                                                                 st = mary->get_baseStruct();
    556                                                                 iter1 = st->get_members().begin();
    557                                                                 break;
    558                                                         } // if
    559                                                 }  // for
    560                                         } // for
    561                                         ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
    562                                         assert( fred );
    563                                         initContext = fred->get_type();
    564                                         (*listInit->begin_initializers())->accept( *this );
    565                                 } // if
    566                         } // for
    567                 } else if ( UnionInstType *st = dynamic_cast<UnionInstType*>(initContext) ) {
    568                         DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *st->get_baseUnion()->get_members().begin() );
    569                         initContext = dt->get_type();
    570                         (*listInit->begin_initializers())->accept( *this );
    571                 } // if
    572 #endif
     472                currentObject.enterListInit();
     473                // xxx - fix this so that the list isn't copied, iterator should be used to change current element
     474                std::list<Designation *> newDesignations;
     475                for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
     476                        Designation * des = std::get<0>(p);
     477                        Initializer * init = std::get<1>(p);
     478                        newDesignations.push_back( currentObject.findNext( des ) );
     479                        init->accept( *this );
     480                }
     481                listInit->get_designations() = newDesignations; // xxx - memory management
     482                currentObject.exitListInit();
     483
     484                // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
     485                //      Type * base = tt->get_baseType()->get_base();
     486                //      if ( base ) {
     487                //              // know the implementation type, so try using that as the initContext
     488                //              ObjectDecl tmpObj( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, base->clone(), nullptr );
     489                //              currentObject = &tmpObj;
     490                //              visit( listInit );
     491                //      } else {
     492                //              // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
     493                //              Parent::visit( listInit );
     494                //      }
     495                // } else {
    573496        }
    574497
  • src/ResolvExpr/module.mk

    rc6d2e93 re4d829b  
    66## file "LICENCE" distributed with Cforall.
    77##
    8 ## module.mk -- 
     8## module.mk --
    99##
    1010## Author           : Richard C. Bilson
     
    3131       ResolvExpr/PolyCost.cc \
    3232       ResolvExpr/Occurs.cc \
    33        ResolvExpr/TypeEnvironment.cc
     33       ResolvExpr/TypeEnvironment.cc \
     34       ResolvExpr/CurrentObject.cc
  • src/SymTab/Autogen.h

    rc6d2e93 re4d829b  
    103103                }
    104104
    105                 ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
     105                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) );
    106106
    107107                UntypedExpr *cond = new UntypedExpr( cmp );
  • src/SynTree/Expression.cc

    rc6d2e93 re4d829b  
    9292
    9393        Declaration *decl = get_var();
    94         // if ( decl != 0) decl->print(os, indent + 2);
    9594        if ( decl != 0) decl->printShort(os, indent + 2);
    9695        os << std::endl;
     
    670669}
    671670
     671InitAlternative::InitAlternative( Type * type, Designation * designation ) : type( type ), designation( designation ) {}
     672InitAlternative::InitAlternative( const InitAlternative & other ) : type( maybeClone( other.type ) ), designation( maybeClone( other.designation ) ) {}
     673InitAlternative::~InitAlternative() {
     674        delete type;
     675        delete designation;
     676}
     677
     678UntypedInitExpr::UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts ) : expr( expr ), initAlts( initAlts ) {}
     679UntypedInitExpr::UntypedInitExpr( const UntypedInitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), initAlts( other.initAlts ) {}
     680UntypedInitExpr::~UntypedInitExpr() {
     681        delete expr;
     682}
     683
     684void UntypedInitExpr::print( std::ostream & os, int indent ) const {
     685        os << "Untyped Init Expression" << std::endl << std::string( indent+2, ' ' );
     686        expr->print( os, indent+2 );
     687        if ( ! initAlts.empty() ) {
     688                for ( const InitAlternative & alt : initAlts ) {
     689                        os << std::string( indent+2, ' ' ) <<  "InitAlternative: ";
     690                        alt.type->print( os, indent+2 );
     691                        alt.designation->print( os, indent+2 );
     692                }
     693        }
     694}
     695
     696InitExpr::InitExpr( Expression * expr, Type * type, Designation * designation ) : expr( expr ), designation( designation ) {
     697        set_result( type );
     698}
     699InitExpr::InitExpr( const InitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), designation( maybeClone( other.designation) ) {}
     700InitExpr::~InitExpr() {
     701        delete expr;
     702        delete designation;
     703}
     704
     705void InitExpr::print( std::ostream & os, int indent ) const {
     706        os << "Init Expression" << std::endl << std::string( indent+2, ' ' );
     707        expr->print( os, indent+2 );
     708        os << std::string( indent+2, ' ' ) << "with designation: ";
     709        designation->print( os, indent+2 );
     710}
     711
     712
    672713std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
    673714        if ( expr ) {
  • src/SynTree/Expression.h

    rc6d2e93 re4d829b  
    781781};
    782782
     783struct InitAlternative {
     784public:
     785        Type * type = nullptr;
     786        Designation * designation = nullptr;
     787        InitAlternative( Type * type, Designation * designation );
     788        InitAlternative( const InitAlternative & other );
     789        InitAlternative & operator=( const Initializer & other ) = delete; // at the moment this isn't used, and I don't want to implement it
     790        ~InitAlternative();
     791};
     792
     793class UntypedInitExpr : public Expression {
     794public:
     795        UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts );
     796        UntypedInitExpr( const UntypedInitExpr & other );
     797        ~UntypedInitExpr();
     798
     799        Expression * get_expr() const { return expr; }
     800        UntypedInitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
     801
     802        std::list<InitAlternative> & get_initAlts() { return initAlts; }
     803
     804        virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * this ); }
     805        virtual void accept( Visitor & v ) { v.visit( this ); }
     806        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     807        virtual void print( std::ostream & os, int indent = 0 ) const;
     808private:
     809        Expression * expr;
     810        std::list<InitAlternative> initAlts;
     811};
     812
     813class InitExpr : public Expression {
     814public:
     815        InitExpr( Expression * expr, Type * type, Designation * designation );
     816        InitExpr( const InitExpr & other );
     817        ~InitExpr();
     818
     819        Expression * get_expr() const { return expr; }
     820        InitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
     821
     822        Designation * get_designation() const { return designation; }
     823        InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; }
     824
     825        virtual InitExpr * clone() const { return new InitExpr( * this ); }
     826        virtual void accept( Visitor & v ) { v.visit( this ); }
     827        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     828        virtual void print( std::ostream & os, int indent = 0 ) const;
     829private:
     830        Expression * expr;
     831        Designation * designation;
     832};
     833
     834
    783835std::ostream & operator<<( std::ostream & out, const Expression * expr );
    784836
  • src/SynTree/Initializer.cc

    rc6d2e93 re4d829b  
    1919#include "Common/utility.h"
    2020
     21Designation::Designation( const std::list< Expression * > & designators ) : designators( designators ) {}
     22Designation::Designation( const Designation & other ) : BaseSyntaxNode( other ) {
     23        // std::cerr << "cloning designation" << std::endl;
     24        cloneAll( other.designators, designators );
     25        // std::cerr << "finished cloning designation" << std::endl;
     26}
     27
     28Designation::~Designation() {
     29        // std::cerr << "destroying designation" << std::endl;
     30        deleteAll( designators );
     31        // std::cerr << "finished destroying designation" << std::endl;
     32}
     33
     34void Designation::print( std::ostream &os, int indent ) const {
     35        if ( ! designators.empty() ) {
     36                os << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
     37                for ( std::list < Expression * >::const_iterator i = designators.begin(); i != designators.end(); i++ ) {
     38                        os << std::string(indent + 4, ' ' );
     39                        ( *i )->print(os, indent + 4 );
     40                }
     41                os << std::endl;
     42        } // if
     43}
     44
     45
    2146Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {}
    2247Initializer::Initializer( const Initializer & other ) : BaseSyntaxNode( other ), maybeConstructed( other.maybeConstructed ) {
    2348}
    24 
    25 
    2649Initializer::~Initializer() {}
    2750
    28 std::string Initializer::designator_name( Expression *des ) {
    29         if ( NameExpr *n = dynamic_cast<NameExpr *>(des) )
    30                 return n->get_name();
    31         else
    32                 throw 0;
    33 }
    34 
    35 void Initializer::print( std::ostream &os, int indent ) {}
    36 
    37 SingleInit::SingleInit( Expression *v, const std::list< Expression *> &_designators, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ), designators( _designators ) {
     51SingleInit::SingleInit( Expression *v, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ) {
    3852}
    3953
    4054SingleInit::SingleInit( const SingleInit &other ) : Initializer(other), value ( maybeClone( other.value ) ) {
    41         cloneAll(other.designators, designators );
    4255}
    4356
    4457SingleInit::~SingleInit() {
    4558        delete value;
    46         deleteAll(designators);
    4759}
    4860
    49 void SingleInit::print( std::ostream &os, int indent ) {
    50         os << std::endl << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
     61void SingleInit::print( std::ostream &os, int indent ) const {
     62        os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
    5163        os << std::string(indent+4, ' ' );
    5264        value->print( os, indent+4 );
    53 
    54         if ( ! designators.empty() ) {
    55                 os << std::endl << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
    56                 for ( std::list < Expression * >::iterator i = designators.begin(); i != designators.end(); i++ ) {
    57                         os << std::string(indent + 4, ' ' );
    58                         ( *i )->print(os, indent + 4 );
    59                 }
    60         } // if
    6165}
    6266
    63 ListInit::ListInit( const std::list<Initializer*> &_initializers, const std::list<Expression *> &_designators, bool maybeConstructed )
    64         : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) {
     67
     68ListInit::ListInit( const std::list<Initializer*> &initializers, const std::list<Designation *> &designations, bool maybeConstructed )
     69        : Initializer( maybeConstructed ), initializers( initializers ), designations( designations ) {
    6570}
    6671
    6772ListInit::ListInit( const ListInit & other ) : Initializer( other ) {
    6873        cloneAll( other.initializers, initializers );
    69         cloneAll( other.designators, designators );
     74        cloneAll( other.designations, designations );
    7075}
    71 
    7276
    7377ListInit::~ListInit() {
    7478        deleteAll( initializers );
    75         deleteAll( designators );
     79        deleteAll( designations );
    7680}
    7781
    78 void ListInit::print( std::ostream &os, int indent ) {
    79         os << std::endl << std::string(indent, ' ') << "Compound initializer:  ";
    80         if ( ! designators.empty() ) {
    81                 os << std::string(indent + 2, ' ' ) << "designated by: [";
    82                 for ( std::list < Expression * >::iterator i = designators.begin();
    83                           i != designators.end(); i++ ) {
    84                         ( *i )->print(os, indent + 4 );
    85                 } // for
     82void ListInit::print( std::ostream &os, int indent ) const {
     83        os << std::string(indent, ' ') << "Compound initializer:  " << std::endl;
     84        for ( Designation * d : designations ) {
     85                d->print( os, indent + 2 );
     86        }
    8687
    87                 os << std::string(indent + 2, ' ' ) << "]";
    88         } // if
    89 
    90         for ( std::list<Initializer *>::iterator i = initializers.begin(); i != initializers.end(); i++ )
    91                 (*i)->print( os, indent + 2 );
     88        for ( const Initializer * init : initializers ) {
     89                init->print( os, indent + 2 );
     90                os << std::endl;
     91        }
    9292}
    9393
     
    103103}
    104104
    105 void ConstructorInit::print( std::ostream &os, int indent ) {
     105void ConstructorInit::print( std::ostream &os, int indent ) const {
    106106        os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl;
    107107        if ( ctor ) {
     
    124124}
    125125
    126 std::ostream & operator<<( std::ostream & out, Initializer * init ) {
    127         init->print( out );
     126std::ostream & operator<<( std::ostream & out, const Initializer * init ) {
     127        if ( init ) {
     128                init->print( out );
     129        } else {
     130                out << "nullptr";
     131        }
     132        return out;
     133}
     134
     135std::ostream & operator<<( std::ostream & out, const Designation * des ) {
     136        if ( des ) {
     137                des->print( out );
     138        } else {
     139                out << "nullptr";
     140        }
    128141        return out;
    129142}
  • src/SynTree/Initializer.h

    rc6d2e93 re4d829b  
    2525#include "Visitor.h"
    2626
    27 const std::list<Expression*> noDesignators;
     27// Designation: list of designator (NameExpr, VariableExpr, and ConstantExpr) expressions that specify an object being initialized.
     28class Designation : public BaseSyntaxNode {
     29public:
     30        Designation( const std::list< Expression * > & designators );
     31        Designation( const Designation & other );
     32        virtual ~Designation();
     33
     34        std::list< Expression * > & get_designators() { return designators; }
     35
     36        virtual Designation * clone() const { return new Designation( *this ); };
     37        virtual void accept( Visitor &v ) { v.visit( this ); }
     38        virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
     39        virtual void print( std::ostream &os, int indent = 0 ) const;
     40private:
     41        std::list< Expression * > designators;
     42};
     43
     44const std::list<Designation *> noDesignators;
    2845
    2946// Initializer: base class for object initializers (provide default values)
    3047class Initializer : public BaseSyntaxNode {
    3148  public:
    32         //      Initializer( std::string _name = std::string(""), int _pos = 0 );
    3349        Initializer( bool maybeConstructed );
    3450        Initializer( const Initializer & other );
    3551        virtual ~Initializer();
    36 
    37         static std::string designator_name( Expression *designator );
    38 
    39         //      void set_name( std::string newValue ) { name = newValue; }
    40         //      std::string get_name() const { return name; }
    41 
    42         //      void set_pos( int newValue ) { pos = newValue; }
    43         //      int get_pos() const { return pos; }
    44         virtual void set_designators( std::list<Expression *> & ) { assert(false); }
    45         virtual std::list<Expression *> &get_designators() {
    46                 assert(false);
    47                 std::list<Expression *> *ret = 0; return *ret;  // never reached
    48         }
    4952
    5053        bool get_maybeConstructed() { return maybeConstructed; }
     
    5356        virtual void accept( Visitor &v ) = 0;
    5457        virtual Initializer *acceptMutator( Mutator &m ) = 0;
    55         virtual void print( std::ostream &os, int indent = 0 );
     58        virtual void print( std::ostream &os, int indent = 0 ) const = 0;
    5659  private:
    57         //      std::string name;
    58         //      int pos;
    5960        bool maybeConstructed;
    6061};
     
    6364class SingleInit : public Initializer {
    6465  public:
    65         SingleInit( Expression *value, const std::list< Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
     66        SingleInit( Expression *value, bool maybeConstructed = false );
    6667        SingleInit( const SingleInit &other );
    6768        virtual ~SingleInit();
     
    7071        void set_value( Expression *newValue ) { value = newValue; }
    7172
    72         std::list<Expression *> &get_designators() { return designators; }
    73         void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
    74 
    7573        virtual SingleInit *clone() const { return new SingleInit( *this); }
    7674        virtual void accept( Visitor &v ) { v.visit( this ); }
    7775        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    78         virtual void print( std::ostream &os, int indent = 0 );
     76        virtual void print( std::ostream &os, int indent = 0 ) const;
    7977  private:
    8078        //Constant *value;
    8179        Expression *value;      // has to be a compile-time constant
    82         std::list< Expression * > designators;
    8380};
    8481
     
    8885  public:
    8986        ListInit( const std::list<Initializer*> &initializers,
    90                           const std::list<Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
     87                          const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
    9188        ListInit( const ListInit & other );
    9289        virtual ~ListInit();
    9390
    94         void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
    95         std::list<Expression *> &get_designators() { return designators; }
    96         void set_initializers( std::list<Initializer*> &newValue ) { initializers = newValue; }
    97         std::list<Initializer*> &get_initializers() { return initializers; }
     91        std::list<Designation *> & get_designations() { return designations; }
     92        std::list<Initializer *> & get_initializers() { return initializers; }
    9893
    9994        typedef std::list<Initializer*>::iterator iterator;
     95        typedef std::list<Initializer*>::const_iterator const_iterator;
    10096        iterator begin() { return initializers.begin(); }
    10197        iterator end() { return initializers.end(); }
     98        const_iterator begin() const { return initializers.begin(); }
     99        const_iterator end() const { return initializers.end(); }
    102100
    103101        virtual ListInit *clone() const { return new ListInit( *this ); }
    104102        virtual void accept( Visitor &v ) { v.visit( this ); }
    105103        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    106         virtual void print( std::ostream &os, int indent = 0 );
     104        virtual void print( std::ostream &os, int indent = 0 ) const;
    107105  private:
    108         std::list<Initializer*> initializers;  // order *is* important
    109         std::list<Expression *> designators;
     106        std::list<Initializer *> initializers;  // order *is* important
     107        std::list<Designation *> designations;  // order/length is consistent with initializers
    110108};
    111109
     
    130128        virtual void accept( Visitor &v ) { v.visit( this ); }
    131129        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    132         virtual void print( std::ostream &os, int indent = 0 );
     130        virtual void print( std::ostream &os, int indent = 0 ) const;
    133131
    134132  private:
     
    140138};
    141139
    142 std::ostream & operator<<( std::ostream & out, Initializer * init );
     140std::ostream & operator<<( std::ostream & out, const Initializer * init );
     141std::ostream & operator<<( std::ostream & out, const Designation * des );
    143142
    144143#endif // INITIALIZER_H
  • src/SynTree/Mutator.cc

    rc6d2e93 re4d829b  
    439439}
    440440
     441Expression *Mutator::mutate( UntypedInitExpr * initExpr ) {
     442        initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
     443        initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
     444        initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) );
     445        // not currently mutating initAlts, but this doesn't matter since this node is only used in the resolver.
     446        return initExpr;
     447}
     448
     449Expression *Mutator::mutate( InitExpr * initExpr ) {
     450        initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
     451        initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
     452        initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) );
     453        initExpr->set_designation( maybeMutate( initExpr->get_designation(), *this ) );
     454        return initExpr;
     455}
     456
    441457
    442458Type *Mutator::mutate( VoidType *voidType ) {
     
    541557
    542558
     559Designation *Mutator::mutate( Designation * designation ) {
     560        mutateAll( designation->get_designators(), *this );
     561        return designation;
     562}
     563
    543564Initializer *Mutator::mutate( SingleInit *singleInit ) {
    544565        singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
     
    547568
    548569Initializer *Mutator::mutate( ListInit *listInit ) {
    549         mutateAll( listInit->get_designators(), *this );
     570        mutateAll( listInit->get_designations(), *this );
    550571        mutateAll( listInit->get_initializers(), *this );
    551572        return listInit;
  • src/SynTree/Mutator.h

    rc6d2e93 re4d829b  
    8686        virtual Expression* mutate( StmtExpr * stmtExpr );
    8787        virtual Expression* mutate( UniqueExpr * uniqueExpr );
     88        virtual Expression* mutate( UntypedInitExpr * initExpr );
     89        virtual Expression* mutate( InitExpr * initExpr );
    8890
    8991        virtual Type* mutate( VoidType *basicType );
     
    104106        virtual Type* mutate( OneType *oneType );
    105107
     108        virtual Designation* mutate( Designation *designation );
    106109        virtual Initializer* mutate( SingleInit *singleInit );
    107110        virtual Initializer* mutate( ListInit *listInit );
  • src/SynTree/SynTree.h

    rc6d2e93 re4d829b  
    9393class StmtExpr;
    9494class UniqueExpr;
     95class UntypedInitExpr;
     96class InitExpr;
    9597
    9698class Type;
     
    113115class OneType;
    114116
     117class Designation;
    115118class Initializer;
    116119class SingleInit;
  • src/SynTree/Visitor.cc

    rc6d2e93 re4d829b  
    344344}
    345345
     346void Visitor::visit( UntypedInitExpr * initExpr ) {
     347        maybeAccept( initExpr->get_result(), *this );
     348        maybeAccept( initExpr->get_expr(), *this );
     349        // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
     350}
     351
     352void Visitor::visit( InitExpr * initExpr ) {
     353        maybeAccept( initExpr->get_result(), *this );
     354        maybeAccept( initExpr->get_expr(), *this );
     355        maybeAccept( initExpr->get_designation(), *this );
     356}
     357
    346358
    347359void Visitor::visit( VoidType *voidType ) {
     
    428440}
    429441
     442void Visitor::visit( Designation * designation ) {
     443        acceptAll( designation->get_designators(), *this );
     444}
    430445
    431446void Visitor::visit( SingleInit *singleInit ) {
     
    434449
    435450void Visitor::visit( ListInit *listInit ) {
    436         acceptAll( listInit->get_designators(), *this );
     451        acceptAll( listInit->get_designations(), *this );
    437452        acceptAll( listInit->get_initializers(), *this );
    438453}
  • src/SynTree/Visitor.h

    rc6d2e93 re4d829b  
    8989        virtual void visit( StmtExpr * stmtExpr );
    9090        virtual void visit( UniqueExpr * uniqueExpr );
     91        virtual void visit( UntypedInitExpr * initExpr );
     92        virtual void visit( InitExpr * initExpr );
    9193
    9294        virtual void visit( VoidType *basicType );
     
    107109        virtual void visit( OneType *oneType );
    108110
     111        virtual void visit( Designation *designation );
    109112        virtual void visit( SingleInit *singleInit );
    110113        virtual void visit( ListInit *listInit );
     
    163166                        } // if
    164167                } catch( SemanticError &e ) {
    165                         e.set_location( (*i)->location );                       
     168                        e.set_location( (*i)->location );
    166169                        errors.append( e );
    167170                } // try
  • src/Tuples/TupleExpansion.cc

    rc6d2e93 re4d829b  
    192192                        }
    193193                        BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
    194                         ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) );
     194                        ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ) ) );
    195195                        addDeclaration( finished );
    196196                        // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
Note: See TracChangeset for help on using the changeset viewer.