Changeset 62423350

Timestamp:

Jun 29, 2017, 5:06:24 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

a12d5aa

Parents:

bb1cd95

Message:

Big push on designations and initialization: works with generic types, tuples, arrays, tests pass.
Refactor guard_value_impl.
Add list of declarations to TupleType.

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (1 diff)
• Common/PassVisitor.h (modified) (1 diff)
• Common/PassVisitor.impl.h (modified) (2 diffs)
• Common/PassVisitor.proto.h (modified) (2 diffs)
• InitTweak/FixInit.cc (modified) (7 diffs)
• Parser/TypeData.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (3 diffs)
• ResolvExpr/CurrentObject.cc (modified) (17 diffs)
• ResolvExpr/CurrentObject.h (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (2 diffs)
• ResolvExpr/Unify.cc (modified) (4 diffs)
• SymTab/ImplementationType.cc (modified) (2 diffs)
• SynTree/Constant.cc (modified) (2 diffs)
• SynTree/Constant.h (modified) (2 diffs)
• SynTree/Expression.cc (modified) (2 diffs)
• SynTree/Expression.h (modified) (1 diff)
• SynTree/Initializer.cc (modified) (1 diff)
• SynTree/Mutator.cc (modified) (1 diff)
• SynTree/TupleType.cc (modified) (1 diff)
• SynTree/Type.h (modified) (3 diffs)
• SynTree/VarExprReplacer.cc (modified) (1 diff)
• SynTree/VarExprReplacer.h (modified) (1 diff)
• SynTree/Visitor.cc (modified) (1 diff)
• Tuples/TupleExpansion.cc (modified) (1 diff)
• tests/designations.c (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -292 +292 @@
                 if ( designators.size() == 0 ) return;
                 for ( Expression * des : designators ) {
-                        if ( dynamic_cast< ConstantExpr * >( des ) ) {
-                                // if expression is a ConstantExpr, then initializing array element
+                        if ( dynamic_cast< NameExpr * >( des ) || dynamic_cast< VariableExpr * >( des ) ) {
+                                // if expression is a NameExpr or VariableExpr, then initializing aggregate member
+                                output << ".";
+                                des->accept( *this );
+                        } else {
+                                // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt
                                 output << "[";
                                 des->accept( *this );
                                 output << "]";
-                        } else {
-                                // if not a ConstantExpr, it has to be a NameExpr or VariableExpr, initializing aggregate member
-                                output << ".";
-                                des->accept( *this );
                         } // if
                 } // for

src/Common/PassVisitor.h

@@ -257 +257 @@
 
         void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); }
-
-        guard_value_impl init_guard() {
-                guard_value_impl guard;
-                auto at_cleanup = at_cleanup_impl(pass, 0);
-                if( at_cleanup ) {
-                        *at_cleanup = [&guard]( cleanup_func_t && func, void* val ) {
-                                guard.push( std::move( func ), val );
-                        };
-                }
-                return guard;
-        }
 };
 

src/Common/PassVisitor.impl.h

@@ -3 +3 @@
 #define VISIT_START( node )                     \
         __attribute__((unused))                   \
-        const auto & guard = init_guard();        \
+        guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
         bool visit_children = true;               \
         set_visit_children( visit_children );   \
@@ -15 +15 @@
 #define MUTATE_START( node )                    \
         __attribute__((unused))                   \
-        const auto & guard = init_guard();        \
+        guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
         bool visit_children = true;               \
         set_visit_children( visit_children );   \

src/Common/PassVisitor.proto.h

@@ -5 +5 @@
 
 typedef std::function<void( void * )> cleanup_func_t;
+typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t;
 
 class guard_value_impl {
 public:
-        guard_value_impl() = default;
+        guard_value_impl( at_cleanup_t * at_cleanup ) {
+                if( at_cleanup ) {
+                        *at_cleanup = [this]( cleanup_func_t && func, void* val ) {
+                                push( std::move( func ), val );
+                        };
+                }
+        }
 
         ~guard_value_impl() {
@@ -33 +40 @@
 };
 
-typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t;
 
 class bool_ref {

src/InitTweak/FixInit.cc

@@ -104 +104 @@
                         typedef AddStmtVisitor Parent;
                         using Parent::visit;
-                        typedef std::set< ObjectDecl * > ObjectSet;
+                        // use ordered data structure to maintain ordering for set_difference and for consistent error messages
+                        typedef std::list< ObjectDecl * > ObjectSet;
                         virtual void visit( CompoundStmt *compoundStmt ) override;
                         virtual void visit( DeclStmt *stmt ) override;
@@ -116 +117 @@
 
                 // debug
-                struct printSet {
-                        typedef ObjDeclCollector::ObjectSet ObjectSet;
-                        printSet( const ObjectSet & objs ) : objs( objs ) {}
+                template<typename ObjectSet>
+                struct PrintSet {
+                        PrintSet( const ObjectSet & objs ) : objs( objs ) {}
                         const ObjectSet & objs;
                 };
-                std::ostream & operator<<( std::ostream & out, const printSet & set) {
+                template<typename ObjectSet>
+                PrintSet<ObjectSet> printSet( const ObjectSet & objs ) { return PrintSet<ObjectSet>( objs ); }
+                template<typename ObjectSet>
+                std::ostream & operator<<( std::ostream & out, const PrintSet<ObjectSet> & set) {
                         out << "{ ";
                         for ( ObjectDecl * obj : set.objs ) {
@@ -745 +749 @@
 
                                                 Statement * dtor = ctorInit->get_dtor();
-                                                objDecl->set_init( NULL );
-                                                ctorInit->set_ctor( NULL );
+                                                objDecl->set_init( nullptr );
+                                                ctorInit->set_ctor( nullptr );
                                                 ctorInit->set_dtor( nullptr );
                                                 if ( dtor ) {
@@ -799 +803 @@
                                                 } else {
                                                         stmtsToAddAfter.push_back( ctor );
-                                                        objDecl->set_init( NULL );
-                                                        ctorInit->set_ctor( NULL );
+                                                        objDecl->set_init( nullptr );
+                                                        ctorInit->set_ctor( nullptr );
                                                 }
                                         } // if
                                 } else if ( Initializer * init = ctorInit->get_init() ) {
                                         objDecl->set_init( init );
-                                        ctorInit->set_init( NULL );
+                                        ctorInit->set_init( nullptr );
                                 } else {
                                         // no constructor and no initializer, which is okay
-                                        objDecl->set_init( NULL );
+                                        objDecl->set_init( nullptr );
                                 } // if
                                 delete ctorInit;
@@ -816 +820 @@
 
                 void ObjDeclCollector::visit( CompoundStmt * compoundStmt ) {
-                        std::set< ObjectDecl * > prevVars = curVars;
+                        ObjectSet prevVars = curVars;
                         Parent::visit( compoundStmt );
                         curVars = prevVars;
@@ -824 +828 @@
                         // keep track of all variables currently in scope
                         if ( ObjectDecl * objDecl = dynamic_cast< ObjectDecl * > ( stmt->get_decl() ) ) {
-                                curVars.insert( objDecl );
+                                curVars.push_back( objDecl );
                         } // if
                         Parent::visit( stmt );
@@ -939 +943 @@
                         )
                         if ( ! diff.empty() ) {
+                                // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages.
+                                std::unordered_set<ObjectDecl *> needsDestructor( diff.begin(), diff.end() );
+
                                 // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor
                                 OrderedDecls ordered;
                                 for ( OrderedDecls & rdo : reverseDeclOrder ) {
                                         // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order.
-                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return diff.count( objDecl ); } );
+                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } );
                                 } // for
                                 insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAdd ) );

src/Parser/TypeData.cc

@@ -777 +777 @@
 TupleType * buildTuple( const TypeData * td ) {
         assert( td->kind == TypeData::Tuple );
-        TupleType * ret = new TupleType( buildQualifiers( td ) );
-        buildTypeList( td->tuple, ret->get_types() );
+        std::list< Type * > types;
+        buildTypeList( td->tuple, types );
+        TupleType * ret = new TupleType( buildQualifiers( td ), types );
         buildForall( td->forall, ret->get_forall() );
         return ret;

src/ResolvExpr/AlternativeFinder.cc

@@ -809 +809 @@
         }
 
+        Expression * restructureCast( Expression * argExpr, Type * toType ) {
+                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) {
+                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
+                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
+                        // more components of the tuple than components in the target type, then excess components do not
+                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
+                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
+                                // expressions which may contain side effects require a single unique instance of the expression.
+                                argExpr = new UniqueExpr( argExpr );
+                        }
+                        std::list< Expression * > componentExprs;
+                        for ( unsigned int i = 0; i < toType->size(); i++ ) {
+                                // cast each component
+                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
+                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
+                        }
+                        delete argExpr;
+                        assert( componentExprs.size() > 0 );
+                        // produce the tuple of casts
+                        return new TupleExpr( componentExprs );
+                } else {
+                        // handle normally
+                        return new CastExpr( argExpr, toType->clone() );
+                }
+        }
+
         void AlternativeFinder::visit( CastExpr *castExpr ) {
                 Type *& toType = castExpr->get_result();
@@ -840 +866 @@
                                 thisCost += Cost( 0, 0, discardedValues );
 
-                                Expression * argExpr = i->expr->clone();
-                                if ( argExpr->get_result()->size() > 1 && ! castExpr->get_result()->isVoid() ) {
-                                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
-                                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
-                                        // more components of the tuple than components in the target type, then excess components do not
-                                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
-                                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
-                                                // expressions which may contain side effects require a single unique instance of the expression.
-                                                argExpr = new UniqueExpr( argExpr );
-                                        }
-                                        std::list< Expression * > componentExprs;
-                                        for ( unsigned int i = 0; i < castExpr->get_result()->size(); i++ ) {
-                                                // cast each component
-                                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
-                                                componentExprs.push_back( new CastExpr( idx, castExpr->get_result()->getComponent( i )->clone() ) );
-                                        }
-                                        delete argExpr;
-                                        assert( componentExprs.size() > 0 );
-                                        // produce the tuple of casts
-                                        candidates.push_back( Alternative( new TupleExpr( componentExprs ), i->env, i->cost, thisCost ) );
-                                } else {
-                                        // handle normally
-                                        candidates.push_back( Alternative( new CastExpr( argExpr->clone(), toType->clone() ), i->env, i->cost, thisCost ) );
-                                }
+                                candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
                         } // if
                 } // for
@@ -1183 +1186 @@
 
         void AlternativeFinder::visit( UntypedInitExpr *initExpr ) {
-                AlternativeFinder finder( indexer, env );
-                finder.findWithAdjustment( initExpr->get_expr() );
-                // 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'
+                // handle each option like a cast
                 AltList candidates;
-                std::cerr << "untyped init expr: " << initExpr << std::endl;
+                PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; )
                 // O(N^2) checks of d-types with e-types
-                for ( Alternative & alt : finder.get_alternatives() ) {
-                        for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
+                for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
+                        Type * toType = resolveTypeof( initAlt.type, indexer );
+                        SymTab::validateType( toType, &indexer );
+                        adjustExprType( toType, env, indexer );
+                        // Ideally the call to findWithAdjustment could be moved out of the loop, but unfortunately it currently has to occur inside or else
+                        // polymorphic return types are not properly bound to the initialization type, since return type variables are only open for the duration of resolving
+                        // the UntypedExpr. This is only actually an issue in initialization contexts that allow more than one possible initialization type, but it is still suboptimal.
+                        AlternativeFinder finder( indexer, env );
+                        finder.targetType = toType;
+                        finder.findWithAdjustment( initExpr->get_expr() );
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                TypeEnvironment newEnv( alt.env );
                                 AssertionSet needAssertions, haveAssertions;
-                                OpenVarSet openVars;
-                                std::cerr << "  " << initAlt.type << " " << initAlt.designation << std::endl;
+                                OpenVarSet openVars;  // find things in env that don't have a "representative type" and claim those are open vars?
+                                PRINT( std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl; )
                                 // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
                                 // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
                                 // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                                 // to.
-                                int discardedValues = alt.expr->get_result()->size() - initAlt.type->size();
+                                int discardedValues = alt.expr->get_result()->size() - toType->size();
                                 if ( discardedValues < 0 ) continue;
                                 // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
                                 // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
                                 // unification run for side-effects
-                                unify( initAlt.type, alt.expr->get_result(), alt.env, needAssertions, haveAssertions, openVars, indexer );
-
-                                Cost thisCost = castCost( alt.expr->get_result(), initAlt.type, indexer, alt.env );
+                                unify( toType, alt.expr->get_result(), newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
+
+                                Cost thisCost = castCost( alt.expr->get_result(), toType, indexer, newEnv );
                                 if ( thisCost != Cost::infinity ) {
                                         // count one safe conversion for each value that is thrown away
                                         thisCost += Cost( 0, 0, discardedValues );
-                                        candidates.push_back( Alternative( new InitExpr( alt.expr->clone(), initAlt.type->clone(), initAlt.designation->clone() ), alt.env, alt.cost, thisCost ) );
+                                        candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
                                 }
                         }

src/ResolvExpr/CurrentObject.cc

@@ -22 +22 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Type.h"
+#include "SynTree/TypeSubstitution.h"
 
 #if 0
@@ -32 +33 @@
         long long int getConstValue( ConstantExpr * constExpr ) {
                 if ( BasicType * basicType = dynamic_cast< BasicType * >( constExpr->get_result() ) ) {
-                        if ( basicType->get_kind() == BasicType::Char || basicType->get_kind() == BasicType::SignedChar || basicType->get_kind() == BasicType::UnsignedChar ) {
-                                assertf( constExpr->get_constant()->get_value().size() == 3, "constant value with unusual length: %s", constExpr->get_constant()->get_value().c_str() );
-                                return constExpr->get_constant()->get_value()[1];
+                        if ( basicType->isInteger() ) {
+                                return constExpr->get_constant()->get_ival();
                         } else {
-                                return stoll( constExpr->get_constant()->get_value() );
-                        }
+                                assertf( false, "Non-integer constant expression in getConstValue", toString( constExpr ).c_str() ); // xxx - might be semantic error
+                        }
+                } else if ( dynamic_cast< OneType * >( constExpr->get_result() ) ) {
+                        return 1;
+                } else if ( dynamic_cast< ZeroType * >( constExpr->get_result() ) ) {
+                        return 0;
                 } else {
-                        assertf( false, "unhandled type on getConstValue %s", constExpr->get_result() );
+                        assertf( false, "unhandled type on getConstValue %s", toString( constExpr->get_result() ).c_str() ); // xxx - might be semantic error
                 }
         }
@@ -56 +60 @@
         std::ostream & operator<<( std::ostream & out, Indenter & indent ) {
                 return out << std::string(indent.indent, ' ');
+        }
+
+        template< typename AggrInst >
+        TypeSubstitution makeGenericSubstitution( AggrInst * inst ) {
+                assert( inst );
+                assert( inst->get_baseParameters() );
+                std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
+                std::list< Expression * > typeSubs = inst->get_parameters();
+                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
+                return subs;
+        }
+
+        TypeSubstitution makeGenericSubstitution( Type * type ) {
+                if ( StructInstType * inst = dynamic_cast< StructInstType * >( type ) ) {
+                        return makeGenericSubstitution( inst );
+                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( type ) ) {
+                        return makeGenericSubstitution( inst );
+                } else {
+                        return TypeSubstitution();
+                }
         }
 
@@ -135 +159 @@
                 void setSize( Expression * expr ) {
                         if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
-                                size = getConstValue( constExpr ); // xxx - if not a constant expression, it's not simple to determine how long the array actually is, which is necessary for initialization to be done correctly -- fix this
+                                size = getConstValue( constExpr );
                                 PRINT( std::cerr << "array type with size: " << size << std::endl; )
                         }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                                setSize( castExpr->get_arg() );
+                                setSize( castExpr->get_arg() ); // xxx - need to perform the conversion specified by the cast
                         } else {
-                                assertf( false, "unhandled expression in setSize: %s", toString( expr ).c_str() );
+                                assertf( false, "unhandled expression in setSize: %s", toString( expr ).c_str() ); // xxx - if not a constant expression, it's not simple to determine how long the array actually is, which is necessary for initialization to be done correctly -- fix this
                         }
                 }
@@ -231 +255 @@
         class AggregateIterator : public MemberIterator {
         public:
-                typedef std::list<Declaration *>::iterator iterator;
-                const char * kind = ""; // for debug
-                ReferenceToType * inst = nullptr;
-                AggregateDecl * decl = nullptr;
+                typedef std::list<Declaration *> MemberList;
+                typedef MemberList::const_iterator iterator;
+                std::string kind = ""; // for debug
+                std::string name;
+                Type * inst = nullptr;
+                const MemberList & members;
                 iterator curMember;
-                bool atbegin = true; // false at first {small,big}Step -- this struct type is only added to the possibilities at the beginning
+                bool atbegin = true; // false at first {small,big}Step -- this aggr type is only added to the possibilities at the beginning
                 Type * curType = nullptr;
                 MemberIterator * memberIter = nullptr;
-
-                AggregateIterator( const char * kind, ReferenceToType * inst, AggregateDecl * decl ) : kind( kind ), inst( inst ), decl( decl ), curMember( decl->get_members().begin() ) {
+                mutable TypeSubstitution sub;
+
+                AggregateIterator( const std::string & kind, const std::string & name, Type * inst, const MemberList & members ) : kind( kind ), name( name ), inst( inst ), members( members ), curMember( members.begin() ), sub( makeGenericSubstitution( inst ) ) {
                         init();
                 }
@@ -249 +276 @@
 
                 bool init() {
-                        PRINT( std::cerr << "--init()--" << std::endl; )
-                        if ( curMember != decl->get_members().end() ) {
+                        PRINT( std::cerr << "--init()--" << members.size() << std::endl; )
+                        if ( curMember != members.end() ) {
                                 if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( *curMember ) ) {
                                         PRINT( std::cerr << "incremented to field: " << field << std::endl; )
@@ -264 +291 @@
                         if (memberIter && *memberIter) {
                                 std::list<InitAlternative> ret = memberIter->first();
+                                PRINT( std::cerr << "sub: " << sub << std::endl; )
                                 for ( InitAlternative & alt : ret ) {
                                         PRINT( std::cerr << "iterating and adding designators" << std::endl; )
                                         alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) );
+                                        // need to substitute for generic types, so that casts are to concrete types
+                                        PRINT( std::cerr << "  type is: " << alt.type; )
+                                        sub.apply( alt.type ); // also apply to designation??
+                                        PRINT( std::cerr << " ==> " << alt.type << std::endl; )
                                 }
                                 return ret;
@@ -276 +308 @@
                         if ( ! designators.empty() ) {
                                 if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( designators.front() ) ) {
-                                        for ( curMember = decl->get_members().begin(); curMember != decl->get_members().end(); ++curMember ) {
+                                        for ( curMember = members.begin(); curMember != members.end(); ++curMember ) {
                                                 if ( *curMember == varExpr->get_var() ) {
                                                         designators.pop_front();
@@ -282 +314 @@
                                                         memberIter = createMemberIterator( varExpr->get_result() );
                                                         curType = varExpr->get_result();
-                                                        atbegin = curMember == decl->get_members().begin() && designators.empty(); // xxx - is this right??
+                                                        atbegin = curMember == members.begin() && designators.empty(); // xxx - is this the right condition for atbegin??
                                                         memberIter->setPosition( designators );
                                                         return;
                                                 } // if
                                         } // for
-                                        assertf( false, "could not find member in %s: %s", kind, toString( varExpr ).c_str() );
+                                        assertf( false, "could not find member in %s: %s", kind.c_str(), toString( varExpr ).c_str() );
                                 } else {
-                                        assertf( false, "bad designator given to %s: %s", kind, toString( designators.front() ).c_str() );
+                                        assertf( false, "bad designator given to %s: %s", kind.c_str(), toString( designators.front() ).c_str() );
                                 } // if
                         } // if
@@ -336 +368 @@
 
                 virtual void print( std::ostream & out, Indenter indent ) const {
-                        out << kind << "(" << decl->get_name() << ")";
+                        out << kind << "(" << name << ")";
                         if ( memberIter ) {
                                 Indenter childIndent = indent+1;
@@ -347 +379 @@
         class UnionIterator : public AggregateIterator {
         public:
-                UnionIterator( UnionInstType * inst ) : AggregateIterator( "UnionIterator", inst, inst->get_baseUnion() ) {}
+                UnionIterator( UnionInstType * inst ) : AggregateIterator( "UnionIterator", inst->get_name(), inst, inst->get_baseUnion()->get_members() ) {}
 
                 virtual operator bool() const { return (memberIter && *memberIter); }
@@ -357 +389 @@
                         memberIter = nullptr;
                         curType = nullptr;
-                        curMember = decl->get_members().end();
+                        curMember = members.end();
                         return *this;
                 }
@@ -365 +397 @@
         class StructIterator : public AggregateIterator {
         public:
-                StructIterator( StructInstType * inst ) : AggregateIterator( "StructIterator", inst, inst->get_baseStruct() ) {}
-
-                virtual operator bool() const { return curMember != decl->get_members().end() || (memberIter && *memberIter); }
+                StructIterator( StructInstType * inst ) : AggregateIterator( "StructIterator", inst->get_name(), inst, inst->get_baseStruct()->get_members() ) {}
+
+                virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); }
 
                 virtual MemberIterator & bigStep() {
@@ -375 +407 @@
                         memberIter = nullptr;
                         curType = nullptr;
-                        for ( ; curMember != decl->get_members().end(); ) {
+                        for ( ; curMember != members.end(); ) {
+                                ++curMember;
+                                if ( init() ) {
+                                        return *this;
+                                }
+                        }
+                        return *this;
+                }
+        };
+
+        class TupleIterator : public AggregateIterator {
+        public:
+                TupleIterator( TupleType * inst ) : AggregateIterator( "TupleIterator", toString("Tuple", inst->size()), inst, inst->get_members() ) {}
+
+                virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); }
+
+                virtual MemberIterator & bigStep() {
+                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
+                        atbegin = false;
+                        delete memberIter;
+                        memberIter = nullptr;
+                        curType = nullptr;
+                        for ( ; curMember != members.end(); ) {
                                 ++curMember;
                                 if ( init() ) {
@@ -392 +446 @@
                                 return new UnionIterator( uit );
                         } else {
-                                assertf( false, "some other reftotype" );
+                                assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype" );
+                                return new SimpleIterator( type );
                         }
                 } else if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         return new ArrayIterator( at );
+                } else if ( TupleType * tt = dynamic_cast< TupleType * >( type ) ) {
+                        return new TupleIterator( tt );
                 } else {
                         return new SimpleIterator( type );
@@ -494 +551 @@
                 Type * type = objStack.top()->getNext();
                 if ( type ) {
-                        // xxx - record types.front()?
                         objStack.push( createMemberIterator( type ) );
                 } else {
@@ -517 +573 @@
                 return **objStack.top();
         }
+
+        Type * CurrentObject::getCurrentType() {
+                PRINT( std::cerr << "____getting current type" << std::endl; )
+                assertf( ! objStack.empty(), "objstack empty in getCurrentType" );
+                return objStack.top()->getNext();
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/CurrentObject.h

@@ -42 +42 @@
                 /// produces a list of alternatives (Type *, Designation *) for the current sub-object's initializer
                 std::list< InitAlternative > getOptions();
+                /// produces the type of the current object but no subobjects
+                Type * getCurrentType();
 
         private:

src/ResolvExpr/Resolver.cc

@@ -375 +375 @@
         }
 
-        template< typename Aggr >
-        void lookupDesignation( Aggr * aggr, const std::list< Expression > & designators ) {
-
-        }
-
         void Resolver::visit( SingleInit *singleInit ) {
+                // resolve initialization using the possibilities as determined by the currentObject cursor
                 UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
                 Expression * newExpr = findSingleExpression( untyped, *this );
                 InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
-                singleInit->set_value( new CastExpr( initExpr->get_expr()->clone(), initExpr->get_result()->clone() ) );
+
+                // move cursor to the object that is actually initialized
                 currentObject.setNext( initExpr->get_designation() );
+
+                // discard InitExpr wrapper and retain relevant pieces
+                newExpr = initExpr->get_expr();
+                singleInit->get_value()->set_env( initExpr->get_env() );
+                initExpr->set_expr( nullptr );
+                initExpr->set_env( nullptr );
+                delete initExpr;
+
+                // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
+                Type * initContext = currentObject.getCurrentType();
+
+                // check if actual object's type is char[]
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
+                        if ( isCharType( at->get_base() ) ) {
+                                // check if the resolved type is char *
+                                if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
+                                        if ( isCharType( pt->get_base() ) ) {
+                                                // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                CastExpr *ce = safe_dynamic_cast< CastExpr * >( newExpr );
+                                                newExpr = ce->get_arg();
+                                                ce->set_arg( nullptr );
+                                                delete ce;
+                                        }
+                                }
+                        }
+                }
+
+                // set initializer expr to resolved express
+                singleInit->set_value( newExpr );
+
+                // move cursor to next object in preparation for next initializer
                 currentObject.increment();
-                delete initExpr;
-
-                // // check if initializing type is char[]
-                // if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
-                //      if ( isCharType( at->get_base() ) ) {
-                //              // check if the resolved type is char *
-                //              if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
-                //                      if ( isCharType( pt->get_base() ) ) {
-                //                              // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
-                //                              CastExpr *ce = dynamic_cast< CastExpr * >( newExpr );
-                //                              singleInit->set_value( ce->get_arg() );
-                //                              ce->set_arg( NULL );
-                //                              delete ce;
-                //                      }
-                //              }
-                //      }
-                // }
-        }
-
-        // template< typename AggrInst >
-        // TypeSubstitution makeGenericSubstitution( AggrInst * inst ) {
-        //      assert( inst );
-        //      assert( inst->get_baseParameters() );
-        //      std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
-        //      std::list< Expression * > typeSubs = inst->get_parameters();
-        //      TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
-        //      return subs;
-        // }
-
-        // ReferenceToType * isStructOrUnion( Type * type ) {
-        //      if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) {
-        //              return sit;
-        //      } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) {
-        //              return uit;
-        //      }
-        //      return nullptr;
-        // }
-
-        // void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) {
-        //      ObjectDecl * obj = dynamic_cast< ObjectDecl * >( dcl );
-        //      assert( obj );
-        //      // need to substitute for generic types, so that casts are to concrete types
-        //      currentObject = obj->clone();  // xxx - delete this
-        //      sub.apply( currentObject );
-
-        //      try {
-        //              if ( init == initEnd ) return; // stop when there are no more initializers
-        //              (*init)->accept( *this );
-        //              ++init; // made it past an initializer
-        //      } catch( SemanticError & ) {
-        //              // need to delve deeper, if you can
-        //              if ( ReferenceToType * type = isStructOrUnion( currentObject->get_type() ) ) {
-        //                      resolveAggrInit( type, init, initEnd );
-        //              } else {
-        //                      // member is not an aggregate type, so can't go any deeper
-
-        //                      // might need to rethink what is being thrown
-        //                      throw;
-        //              } // if
-        //      }
-        // }
-
-        // void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) {
-        //      if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) {
-        //              TypeSubstitution sub = makeGenericSubstitution( sit );
-        //              StructDecl * st = sit->get_baseStruct();
-        //              if(st->get_members().empty()) return;
-        //              // want to resolve each initializer to the members of the struct,
-        //              // but if there are more initializers than members we should stop
-        //              list< Declaration * >::iterator it = st->get_members().begin();
-        //              for ( ; it != st->get_members().end(); ++it) {
-        //                      resolveSingleAggrInit( *it, init, initEnd, sub );
-        //              }
-        //      } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) {
-        //              TypeSubstitution sub = makeGenericSubstitution( uit );
-        //              UnionDecl * un = uit->get_baseUnion();
-        //              if(un->get_members().empty()) return;
-        //              // only resolve to the first member of a union
-        //              resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub );
-        //      } // if
-        // }
+        }
 
         void Resolver::visit( ListInit * listInit ) {
+                // move cursor into brace-enclosed initializer-list
                 currentObject.enterListInit();
                 // xxx - fix this so that the list isn't copied, iterator should be used to change current element
                 std::list<Designation *> newDesignations;
                 for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
+                        // iterate designations and initializers in pairs, moving the cursor to the current designated object and resolving
+                        // the initializer against that object.
                         Designation * des = std::get<0>(p);
                         Initializer * init = std::get<1>(p);
@@ -479 +430 @@
                         init->accept( *this );
                 }
+                // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
                 listInit->get_designations() = newDesignations; // xxx - memory management
                 currentObject.exitListInit();
 
+                // xxx - this part has not be folded into CurrentObject yet
                 // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
                 //      Type * base = tt->get_baseType()->get_base();

src/ResolvExpr/Unify.cc

@@ -606 +606 @@
                         } else if ( tupleParam ) {
                                 // bundle other parameters into tuple to match
-                                TupleType* binder = new TupleType{ paramTy->get_qualifiers() };
+                                std::list< Type * > binderTypes;
 
                                 do {
-                                        binder->get_types().push_back( otherParam->get_type()->clone() );
+                                        binderTypes.push_back( otherParam->get_type()->clone() );
                                         ++jt;
 
@@ -618 +618 @@
                                 } while (true);
 
-                                otherParamTy = binder;
+                                otherParamTy = new TupleType{ paramTy->get_qualifiers(), binderTypes };
                                 ++it;  // skip ttype parameter for break
                         } else if ( otherTupleParam ) {
                                 // bundle parameters into tuple to match other
-                                TupleType* binder = new TupleType{ otherParamTy->get_qualifiers() };
+                                std::list< Type * > binderTypes;
 
                                 do {
-                                        binder->get_types().push_back( param->get_type()->clone() );
+                                        binderTypes.push_back( param->get_type()->clone() );
                                         ++it;
 
@@ -634 +634 @@
                                 } while (true);
 
-                                paramTy = binder;
+                                paramTy = new TupleType{ otherParamTy->get_qualifiers(), binderTypes };
                                 ++jt;  // skip ttype parameter for break
                         }
@@ -756 +756 @@
                         return function->get_returnVals().front()->get_type()->clone();
                 } else {
-                        TupleType * tupleType = new TupleType( Type::Qualifiers() );
+                        std::list< Type * > types;
                         for ( DeclarationWithType * decl : function->get_returnVals() ) {
-                                tupleType->get_types().push_back( decl->get_type()->clone() );
+                                types.push_back( decl->get_type()->clone() );
                         } // for
-                        return tupleType;
+                        return new TupleType( Type::Qualifiers(), types );
                 }
         }

src/SymTab/ImplementationType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ImplementationType.cc -- 
+// ImplementationType.cc --
 //
 // Author           : Richard C. Bilson
@@ -92 +92 @@
 
         void ImplementationType::visit(TupleType *tupleType) {
-                TupleType *newType = new TupleType( Type::Qualifiers() );
+                std::list< Type * > types;
                 for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) {
                         Type *implType = implementationType( *i, indexer );
                         implType->get_qualifiers() |= tupleType->get_qualifiers();
-                        newType->get_types().push_back( implType );
+                        types.push_back( implType );
                 } // for
-                result = newType;
+                result = new TupleType( Type::Qualifiers(), types );
         }
 

src/SynTree/Constant.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Constant.cc -- 
+// Constant.cc --
 //
 // Author           : Richard C. Bilson
@@ -46 +46 @@
 }
 
+unsigned long long Constant::get_ival() const {
+        assertf( safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );
+        return val.ival;
+}
+
+double Constant::get_dval() const {
+        assertf( ! safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." );
+        return val.dval;
+}
+
 void Constant::print( std::ostream &os ) const {
         os << "(" << rep << " " << val.ival;

src/SynTree/Constant.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Constant.h -- 
+// Constant.h --
 //
 // Author           : Richard C. Bilson
@@ -32 +32 @@
         std::string & get_value() { return rep; }
         void set_value( std::string newValue ) { rep = newValue; }
+        unsigned long long get_ival() const;
+        double get_dval() const;
 
         /// generates a boolean constant of the given bool

src/SynTree/Expression.cc

@@ -21 +21 @@
 #include <iterator>
 
+#include "Declaration.h"
+#include "Expression.h"
+#include "Initializer.h"
+#include "Statement.h"
 #include "Type.h"
-#include "Initializer.h"
-#include "Expression.h"
-#include "Declaration.h"
-#include "Statement.h"
 #include "TypeSubstitution.h"
+#include "VarExprReplacer.h"
+
 #include "Common/utility.h"
+#include "Common/PassVisitor.h"
+
 #include "InitTweak/InitTweak.h"
 
@@ -681 +685 @@
 }
 
-InitExpr::InitExpr( Expression * expr, Type * type, Designation * designation ) : expr( expr ), designation( designation ) {
-        set_result( type );
+InitExpr::InitExpr( Expression * expr, Designation * designation ) : expr( expr ), designation( designation ) {
+        set_result( expr->get_result()->clone() );
 }
 InitExpr::InitExpr( const InitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), designation( maybeClone( other.designation) ) {}

src/SynTree/Expression.h

@@ -776 +776 @@
 class InitExpr : public Expression {
 public:
-        InitExpr( Expression * expr, Type * type, Designation * designation );
+        InitExpr( Expression * expr, Designation * designation );
         InitExpr( const InitExpr & other );
         ~InitExpr();

src/SynTree/Initializer.cc

@@ -65 +65 @@
 
 
-ListInit::ListInit( const std::list<Initializer*> &initializers, const std::list<Designation *> &designations, bool maybeConstructed )
-        : Initializer( maybeConstructed ), initializers( initializers ), designations( designations ) {
+ListInit::ListInit( const std::list<Initializer*> &inits, const std::list<Designation *> &des, bool maybeConstructed )
+        : Initializer( maybeConstructed ), initializers( inits ), designations( des ) {
+                // handle the common case where a ListInit is created without designations by making a list of empty designations with the same length as the initializer
+                if ( designations.empty() ) {
+                        for ( auto & i : initializers ) {
+                                (void)i;
+                                designations.push_back( new Designation( {} ) );
+                        }
+                }
+                assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%d) and designations (%d)", initializers.size(), designations.size() );
 }
 

src/SynTree/Mutator.cc

@@ -515 +515 @@
         mutateAll( tupleType->get_forall(), *this );
         mutateAll( tupleType->get_types(), *this );
+        mutateAll( tupleType->get_members(), *this );
         return tupleType;
 }

src/SynTree/TupleType.cc

@@ -14 +14 @@
 //
 
+#include "Declaration.h"
+#include "Initializer.h"
 #include "Type.h"
 #include "Common/utility.h"
+#include "Parser/LinkageSpec.h"
 
 TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) {
+        for ( Type * t : *this ) {
+                // xxx - this is very awkward. TupleTypes should contain objects so that members can be named, but if they don't have an initializer node then
+                // they end up getting constructors, which end up being inserted causing problems. This happens because the object decls have to be visited so that
+                // their types are kept in sync with the types list here. Ultimately, the types list here should be eliminated and perhaps replaced with a list-view
+                // of the object types list, but I digress. The temporary solution here is to make a ListInit with maybeConstructed = false, that way even when the
+                // object is visited, it is never constructed. Ultimately, a better solution might be either:
+                // a) to separate TupleType from its declarations, into TupleDecl and Tuple{Inst?}Type, ala StructDecl and StructInstType
+                // b) separate initializer nodes better, e.g. add a MaybeConstructed node that is replaced by genInit, rather than what currently exists in a bool
+                members.push_back( new ObjectDecl( "" , Type::StorageClasses(), LinkageSpec::Cforall, nullptr, t->clone(), new ListInit( {}, {}, false ) ) );
+        }
 }
 
 TupleType::TupleType( const TupleType& other ) : Type( other ) {
         cloneAll( other.types, types );
+        cloneAll( other.members, members );
 }
 
 TupleType::~TupleType() {
         deleteAll( types );
+        deleteAll( members );
 }
 

src/SynTree/Type.h

@@ -481 +481 @@
 class TupleType : public Type {
   public:
-        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TupleType( const TupleType& );
         virtual ~TupleType();
@@ -488 +488 @@
         typedef value_type::iterator iterator;
 
-        std::list<Type*>& get_types() { return types; }
+        std::list<Type *> & get_types() { return types; }
         virtual unsigned size() const { return types.size(); };
+
+        // For now, this is entirely synthetic -- tuple types always have unnamed members.
+        // Eventually, we may allow named tuples, in which case members should subsume types
+        std::list<Declaration *> & get_members() { return members; }
 
         iterator begin() { return types.begin(); }
@@ -506 +510 @@
         virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
-        std::list<Type*> types;
+        std::list<Type *> types;
+        std::list<Declaration *> members;
 };
 

src/SynTree/VarExprReplacer.cc

@@ -14 +14 @@
 //
 
+#include "Declaration.h"
 #include "Expression.h"
 #include "VarExprReplacer.h"
 
-VarExprReplacer::VarExprReplacer( const DeclMap & declMap ) : declMap( declMap ) {}
+VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {}
 
 // replace variable with new node from decl map
 void VarExprReplacer::visit( VariableExpr * varExpr ) {
-  // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
-  if ( declMap.count( varExpr->get_var() ) ) {
-    varExpr->set_var( declMap.at( varExpr->get_var() ) );
-  }
+        // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
+        if ( declMap.count( varExpr->get_var() ) ) {
+                if ( debug ) {
+                        std::cerr << "replacing variable reference: " << (void*)varExpr->get_var() << " " << varExpr->get_var() << " with " << (void*)declMap.at( varExpr->get_var() ) << " " << declMap.at( varExpr->get_var() ) << std::endl;
+                }
+                varExpr->set_var( declMap.at( varExpr->get_var() ) );
+        }
 }

src/SynTree/VarExprReplacer.h

@@ -27 +27 @@
 private:
         const DeclMap & declMap;
+  bool debug;
 public:
-        VarExprReplacer( const DeclMap & declMap );
+        VarExprReplacer( const DeclMap & declMap, bool debug = false );
 
         // replace variable with new node from decl map

src/SynTree/Visitor.cc

@@ -407 +407 @@
         acceptAll( tupleType->get_forall(), *this );
         acceptAll( tupleType->get_types(), *this );
+        acceptAll( tupleType->get_members(), *this );
 }
 

src/Tuples/TupleExpansion.cc

@@ -310 +310 @@
         Type * makeTupleType( const std::list< Expression * > & exprs ) {
                 // produce the TupleType which aggregates the types of the exprs
-                TupleType *tupleType = new TupleType( Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ) );
-                Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
+                std::list< Type * > types;
+                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex );
                 for ( Expression * expr : exprs ) {
                         assert( expr->get_result() );
                         if ( expr->get_result()->isVoid() ) {
                                 // if the type of any expr is void, the type of the entire tuple is void
-                                delete tupleType;
                                 return new VoidType( Type::Qualifiers() );
                         }
                         Type * type = expr->get_result()->clone();
-                        tupleType->get_types().push_back( type );
+                        types.push_back( type );
                         // the qualifiers on the tuple type are the qualifiers that exist on all component types
                         qualifiers &= type->get_qualifiers();
                 } // for
                 if ( exprs.empty() ) qualifiers = Type::Qualifiers();
-                return tupleType;
+                return new TupleType( qualifiers, types );
         }
 

src/tests/designations.c

@@ -26 +26 @@
 const int indentAmt = 2;
 void indent(int level) {
-  for (int i = 0; i < level; ++i) {
-    printf(" ");
-  }
+        for (int i = 0; i < level; ++i) {
+                printf(" ");
+        }
 }
 
 // A contains fields with different types (int vs. int *)
 struct A {
-  int x, y;
-  int * ptr;
+        int x, y;
+        int * ptr;
 };
 void printA(struct A a, int level) {
-  indent(level);
-  printf("(A){ %d %d %p }\n", a.x, a.y, a.ptr);
+        indent(level);
+        printf("(A){ %d %d %p }\n", a.x, a.y, a.ptr);
 }
 
 // B contains struct members
 struct B {
-  struct A a0, a1;
+        struct A a0, a1;
 };
 void printB(struct B b, int level) {
-  indent(level);
-  printf("(B){\n");
-  printA(b.a0, level+indentAmt);
-  printA(b.a1, level+indentAmt);
-  indent(level);
-  printf("}\n");
+        indent(level);
+        printf("(B){\n");
+        printA(b.a0, level+indentAmt);
+        printA(b.a1, level+indentAmt);
+        indent(level);
+        printf("}\n");
 }
 
 // C contains an array - tests that after 3 ints, the members of B are initialized.
 struct C {
-  int arr[3];
-  struct B b;
+        int arr[3];
+        struct B b;
 };
 void printC(struct C c, int level) {
-  indent(level);
-  printf("(C){\n");
-  indent(level+indentAmt);
-  printf("(int[]{ %d %d %d }\n", c.arr[0], c.arr[1], c.arr[2]);
-  printB(c.b, level+indentAmt);
-  indent(level);
-  printf("}\n");
+        indent(level);
+        printf("(C){\n");
+        indent(level+indentAmt);
+        printf("(int[]{ %d %d %d }\n", c.arr[0], c.arr[1], c.arr[2]);
+        printB(c.b, level+indentAmt);
+        indent(level);
+        printf("}\n");
 }
 
 // D contains an unnamed aggregate - tests that this doesn't interfere with initialization.
 struct D {
-  struct {
-    int x;
-  };
+        struct {
+                int x;
+        };
 };
 void printD(struct D d, int level) {
-  indent(level);
-  printf("(D){ %d }\n", d.x);
+        indent(level);
+        printf("(D){ %d }\n", d.x);
 }
 
 // E tests unions
 union E {
-  struct A a;
-  struct B b;
-  struct C c;
-  struct D d;
-  int i;
+        struct A a;
+        struct B b;
+        struct C c;
+        struct D d;
+        int i;
 };
 
 int main() {
-  // simple designation case - starting from beginning of structure, leaves ptr default-initialized (zero)
-  struct A y0 = {
-        .x DES 2,
-        .y DES 3
-  };
-
-  // simple initializaiton case - initialize all elements explicitly with no designations
-  struct A y1 = {
-    2, 3, 0
-  };
-
-
-  // use designation to move to member y, leaving x default-initialized (zero)
-  struct A y2 = {
-    .y DES 3,
-    0
-  };
+        // simple designation case - starting from beginning of structure, leaves ptr default-initialized (zero)
+        struct A y0 = {
+                .x DES 2,
+                .y DES 3
+        };
+
+        // simple initializaiton case - initialize all elements explicitly with no designations
+        struct A y1 = {
+                2, 3, 0
+        };
+
+
+        // use designation to move to member y, leaving x default-initialized (zero)
+        struct A y2 = {
+                .y DES 3,
+                0
+        };
 
 #if ERROR
-  struct A yErr0 = {
-    {} // error - empty scalar initializer is illegal
-  };
-#endif
-
-  printf("=====A=====\n");
-  printA(y0, 0);
-  printA(y1, 0);
-  printA(y2, 0);
-  printf("=====A=====\n\n");
-
-  // initialize only first element (z0.a.x), leaving everything else default-initialized (zero), no nested curly-braces
-  struct B z0 = { 5 };
-
-  // some nested curly braces, use designation to 'jump around' within structure, leaving some members default-initialized
-  struct B z1 = {
-    { 3 }, // z1.a0
-    { 4 }, // z1.a1
-    .a0 DES { 5 }, // z1.a0
-    { 6 }, // z1.a1
-    .a0.y DES 2, // z1.a0.y
-    0, // z1.a0.ptr
-  };
-
-  // z2.a0.y and z2.a0.ptr default-initialized, everything else explicit
-  struct B z2 = {
-    { 1 },
-    { 2, 3, 0 }
-  };
-
-  // initialize every member, omitting nested curly braces
-  struct B z3 = {
-    1, 2, 0, 4, 5, 0
-  };
-
-  // no initializer - legal C, but garbage values - don't print this one
-  struct B z4;
-
-  // no curly braces - initialize with object of same type
-  struct B z5 = z2;
-
-  // z6.a0.y and z6.a0.ptr default-initialized, everything else explicit.
-  // no curly braces on z6.a1 initializers
-  struct B z6 = {
-    { 1 },
-    2, 3, 0
-  };
-
-  printf("=====B=====\n");
-  printB(z0, 0);
-  printB(z1, 0);
-  printB(z2, 0);
-  printB(z3, 0);
-  printB(z5, 0);
-  printB(z6, 0);
-  printf("=====B=====\n\n");
-
-  // TODO: what about extra things in a nested init? are empty structs skipped??
-
-  // test that initializing 'past array bound' correctly moves to next member.
-  struct C c1 = {
-    2, 3, 4,  // arr
-    5, 6, 0,  // b.a0
-    7, 8, 0,  // b.a1
-  };
-
-  printf("=====C=====\n");
-  printC(c1, 0);
-  printf("=====C=====\n\n");
+        struct A yErr0 = {
+                {} // error - empty scalar initializer is illegal
+        };
+#endif
+
+        printf("=====A=====\n");
+        printA(y0, 0);
+        printA(y1, 0);
+        printA(y2, 0);
+        printf("=====A=====\n\n");
+
+        // initialize only first element (z0.a.x), leaving everything else default-initialized (zero), no nested curly-braces
+        struct B z0 = { 5 };
+
+        // some nested curly braces, use designation to 'jump around' within structure, leaving some members default-initialized
+        struct B z1 = {
+                { 3 }, // z1.a0
+                { 4 }, // z1.a1
+                .a0 DES { 5 }, // z1.a0
+                { 6 }, // z1.a1
+                .a0.y DES 2, // z1.a0.y
+                0, // z1.a0.ptr
+        };
+
+        // z2.a0.y and z2.a0.ptr default-initialized, everything else explicit
+        struct B z2 = {
+                { 1 },
+                { 2, 3, 0 }
+        };
+
+        // initialize every member, omitting nested curly braces
+        struct B z3 = {
+                1, 2, 0, 4, 5, 0
+        };
+
+        // no initializer - legal C, but garbage values - don't print this one
+        struct B z4;
+
+        // no curly braces - initialize with object of same type
+        struct B z5 = z2;
+
+        // z6.a0.y and z6.a0.ptr default-initialized, everything else explicit.
+        // no curly braces on z6.a1 initializers
+        struct B z6 = {
+                { 1 },
+                2, 3, 0
+        };
+
+        printf("=====B=====\n");
+        printB(z0, 0);
+        printB(z1, 0);
+        printB(z2, 0);
+        printB(z3, 0);
+        printB(z5, 0);
+        printB(z6, 0);
+        printf("=====B=====\n\n");
+
+        // TODO: what about extra things in a nested init? are empty structs skipped??
+
+        // test that initializing 'past array bound' correctly moves to next member.
+        struct C c1 = {
+                2, 3, 4,  // arr
+                5, 6, 0,  // b.a0
+                7, 8, 0,  // b.a1
+        };
+
+        printf("=====C=====\n");
+        printC(c1, 0);
+        printf("=====C=====\n\n");
 
 #if ERROR
-  // nested initializer can't refer to same type in C
-  struct C cErr0 = { c1 };
-
-  // must use curly braces to initialize members
-  struct C cErr1 = 2;
-
-  // can't initialize with array compound literal
-  struct C cErr2 = {
-    (int[3]) { 1, 2, 3 }  // error: array initialized from non-constant array expression
-  };
+        // nested initializer can't refer to same type in C
+        struct C cErr0 = { c1 };
+
+        // must use curly braces to initialize members
+        struct C cErr1 = 2;
+
+        // can't initialize with array compound literal
+        struct C cErr2 = {
+                (int[3]) { 1, 2, 3 }  // error: array initialized from non-constant array expression
+        };
 #endif
 
 #if WARNING
-  // can't initialize array with array - converts to int*
-  int cWarn0_arr[3] = { 1, 2, 3 };
-  struct C cWarn0 = {
-    cWarn0_arr  // warning: initialization makes integer from ptr without cast
-  };
-#endif
-
-  // allowed to have 'too many' initialized lists - essentially they are ignored.
-  int i1 = { 3 };
-
-  // doesn't work yet.
-  // designate unnamed object's members
-  // struct D d = { .x DES 3 };
+        // can't initialize array with array - converts to int*
+        int cWarn0_arr[3] = { 1, 2, 3 };
+        struct C cWarn0 = {
+                cWarn0_arr  // warning: initialization makes integer from ptr without cast
+        };
+#endif
+
+        // allowed to have 'too many' initialized lists - essentially they are ignored.
+        int i1 = { 3 };
+
+        // doesn't work yet.
+        // designate unnamed object's members
+        // struct D d = { .x DES 3 };
 #if ERROR
-  struct D d1 = { .y DES 3 };
-#endif
-
-  // simple union initialization - initialized first member (e0.a)
-  union E e0 = {
-    y0
-  };
-
-  // simple union initialization - initializes first member (e1.a) - with nested initializer list
-  union E e1 = {
-    { 2, 3, 0 }
-  };
-
-  // simple union initialization - initializes first member (e2.a) - without nested initializer list
-  union E e2 = {
-    2, 3, 0
-  };
-
-  // move cursor to e4.b.a0.x and initialize until e3.b.a1.ptr inclusive
-  union E e3 = {
-    .b.a0.x DES 2, 3, 0, 5, 6, 0
-  };
-
-  printf("=====E=====\n");
-  printA(e0.a, 0);
-  printA(e1.a, 0);
-  printA(e2.a, 0);
-  printB(e3.b, 0);
-  printf("=====E=====\n\n");
+        struct D d1 = { .y DES 3 };
+#endif
+
+        // simple union initialization - initialized first member (e0.a)
+        union E e0 = {
+                y0
+        };
+
+        // simple union initialization - initializes first member (e1.a) - with nested initializer list
+        union E e1 = {
+                { 2, 3, 0 }
+        };
+
+        // simple union initialization - initializes first member (e2.a) - without nested initializer list
+        union E e2 = {
+                2, 3, 0
+        };
+
+        // move cursor to e4.b.a0.x and initialize until e3.b.a1.ptr inclusive
+        union E e3 = {
+                .b.a0.x DES 2, 3, 0, 5, 6, 0
+        };
+
+        printf("=====E=====\n");
+        printA(e0.a, 0);
+        printA(e1.a, 0);
+        printA(e2.a, 0);
+        printB(e3.b, 0);
+        printf("=====E=====\n\n");
+
+        // special case of initialization: char[] can be initialized with a string literal
+        const char * str0 = "hello";
+        char str1[] = "hello";
 }