Changeset 6242335


Ignore:
Timestamp:
Jun 29, 2017, 5:06:24 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:
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:
25 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    rbb1cd95 r6242335  
    292292                if ( designators.size() == 0 ) return;
    293293                for ( Expression * des : designators ) {
    294                         if ( dynamic_cast< ConstantExpr * >( des ) ) {
    295                                 // if expression is a ConstantExpr, then initializing array element
     294                        if ( dynamic_cast< NameExpr * >( des ) || dynamic_cast< VariableExpr * >( des ) ) {
     295                                // if expression is a NameExpr or VariableExpr, then initializing aggregate member
     296                                output << ".";
     297                                des->accept( *this );
     298                        } else {
     299                                // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt
    296300                                output << "[";
    297301                                des->accept( *this );
    298302                                output << "]";
    299                         } else {
    300                                 // if not a ConstantExpr, it has to be a NameExpr or VariableExpr, initializing aggregate member
    301                                 output << ".";
    302                                 des->accept( *this );
    303303                        } // if
    304304                } // for
  • src/Common/PassVisitor.h

    rbb1cd95 r6242335  
    257257
    258258        void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); }
    259 
    260         guard_value_impl init_guard() {
    261                 guard_value_impl guard;
    262                 auto at_cleanup = at_cleanup_impl(pass, 0);
    263                 if( at_cleanup ) {
    264                         *at_cleanup = [&guard]( cleanup_func_t && func, void* val ) {
    265                                 guard.push( std::move( func ), val );
    266                         };
    267                 }
    268                 return guard;
    269         }
    270259};
    271260
  • src/Common/PassVisitor.impl.h

    rbb1cd95 r6242335  
    33#define VISIT_START( node )                     \
    44        __attribute__((unused))                   \
    5         const auto & guard = init_guard();        \
     5        guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
    66        bool visit_children = true;               \
    77        set_visit_children( visit_children );   \
     
    1515#define MUTATE_START( node )                    \
    1616        __attribute__((unused))                   \
    17         const auto & guard = init_guard();        \
     17        guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
    1818        bool visit_children = true;               \
    1919        set_visit_children( visit_children );   \
  • src/Common/PassVisitor.proto.h

    rbb1cd95 r6242335  
    55
    66typedef std::function<void( void * )> cleanup_func_t;
     7typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t;
    78
    89class guard_value_impl {
    910public:
    10         guard_value_impl() = default;
     11        guard_value_impl( at_cleanup_t * at_cleanup ) {
     12                if( at_cleanup ) {
     13                        *at_cleanup = [this]( cleanup_func_t && func, void* val ) {
     14                                push( std::move( func ), val );
     15                        };
     16                }
     17        }
    1118
    1219        ~guard_value_impl() {
     
    3340};
    3441
    35 typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t;
    3642
    3743class bool_ref {
  • src/InitTweak/FixInit.cc

    rbb1cd95 r6242335  
    104104                        typedef AddStmtVisitor Parent;
    105105                        using Parent::visit;
    106                         typedef std::set< ObjectDecl * > ObjectSet;
     106                        // use ordered data structure to maintain ordering for set_difference and for consistent error messages
     107                        typedef std::list< ObjectDecl * > ObjectSet;
    107108                        virtual void visit( CompoundStmt *compoundStmt ) override;
    108109                        virtual void visit( DeclStmt *stmt ) override;
     
    116117
    117118                // debug
    118                 struct printSet {
    119                         typedef ObjDeclCollector::ObjectSet ObjectSet;
    120                         printSet( const ObjectSet & objs ) : objs( objs ) {}
     119                template<typename ObjectSet>
     120                struct PrintSet {
     121                        PrintSet( const ObjectSet & objs ) : objs( objs ) {}
    121122                        const ObjectSet & objs;
    122123                };
    123                 std::ostream & operator<<( std::ostream & out, const printSet & set) {
     124                template<typename ObjectSet>
     125                PrintSet<ObjectSet> printSet( const ObjectSet & objs ) { return PrintSet<ObjectSet>( objs ); }
     126                template<typename ObjectSet>
     127                std::ostream & operator<<( std::ostream & out, const PrintSet<ObjectSet> & set) {
    124128                        out << "{ ";
    125129                        for ( ObjectDecl * obj : set.objs ) {
     
    745749
    746750                                                Statement * dtor = ctorInit->get_dtor();
    747                                                 objDecl->set_init( NULL );
    748                                                 ctorInit->set_ctor( NULL );
     751                                                objDecl->set_init( nullptr );
     752                                                ctorInit->set_ctor( nullptr );
    749753                                                ctorInit->set_dtor( nullptr );
    750754                                                if ( dtor ) {
     
    799803                                                } else {
    800804                                                        stmtsToAddAfter.push_back( ctor );
    801                                                         objDecl->set_init( NULL );
    802                                                         ctorInit->set_ctor( NULL );
     805                                                        objDecl->set_init( nullptr );
     806                                                        ctorInit->set_ctor( nullptr );
    803807                                                }
    804808                                        } // if
    805809                                } else if ( Initializer * init = ctorInit->get_init() ) {
    806810                                        objDecl->set_init( init );
    807                                         ctorInit->set_init( NULL );
     811                                        ctorInit->set_init( nullptr );
    808812                                } else {
    809813                                        // no constructor and no initializer, which is okay
    810                                         objDecl->set_init( NULL );
     814                                        objDecl->set_init( nullptr );
    811815                                } // if
    812816                                delete ctorInit;
     
    816820
    817821                void ObjDeclCollector::visit( CompoundStmt * compoundStmt ) {
    818                         std::set< ObjectDecl * > prevVars = curVars;
     822                        ObjectSet prevVars = curVars;
    819823                        Parent::visit( compoundStmt );
    820824                        curVars = prevVars;
     
    824828                        // keep track of all variables currently in scope
    825829                        if ( ObjectDecl * objDecl = dynamic_cast< ObjectDecl * > ( stmt->get_decl() ) ) {
    826                                 curVars.insert( objDecl );
     830                                curVars.push_back( objDecl );
    827831                        } // if
    828832                        Parent::visit( stmt );
     
    939943                        )
    940944                        if ( ! diff.empty() ) {
     945                                // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages.
     946                                std::unordered_set<ObjectDecl *> needsDestructor( diff.begin(), diff.end() );
     947
    941948                                // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor
    942949                                OrderedDecls ordered;
    943950                                for ( OrderedDecls & rdo : reverseDeclOrder ) {
    944951                                        // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order.
    945                                         copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return diff.count( objDecl ); } );
     952                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } );
    946953                                } // for
    947954                                insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAdd ) );
  • src/Parser/TypeData.cc

    rbb1cd95 r6242335  
    777777TupleType * buildTuple( const TypeData * td ) {
    778778        assert( td->kind == TypeData::Tuple );
    779         TupleType * ret = new TupleType( buildQualifiers( td ) );
    780         buildTypeList( td->tuple, ret->get_types() );
     779        std::list< Type * > types;
     780        buildTypeList( td->tuple, types );
     781        TupleType * ret = new TupleType( buildQualifiers( td ), types );
    781782        buildForall( td->forall, ret->get_forall() );
    782783        return ret;
  • src/ResolvExpr/AlternativeFinder.cc

    rbb1cd95 r6242335  
    809809        }
    810810
     811        Expression * restructureCast( Expression * argExpr, Type * toType ) {
     812                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) {
     813                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
     814                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
     815                        // more components of the tuple than components in the target type, then excess components do not
     816                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
     817                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
     818                                // expressions which may contain side effects require a single unique instance of the expression.
     819                                argExpr = new UniqueExpr( argExpr );
     820                        }
     821                        std::list< Expression * > componentExprs;
     822                        for ( unsigned int i = 0; i < toType->size(); i++ ) {
     823                                // cast each component
     824                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
     825                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
     826                        }
     827                        delete argExpr;
     828                        assert( componentExprs.size() > 0 );
     829                        // produce the tuple of casts
     830                        return new TupleExpr( componentExprs );
     831                } else {
     832                        // handle normally
     833                        return new CastExpr( argExpr, toType->clone() );
     834                }
     835        }
     836
    811837        void AlternativeFinder::visit( CastExpr *castExpr ) {
    812838                Type *& toType = castExpr->get_result();
     
    840866                                thisCost += Cost( 0, 0, discardedValues );
    841867
    842                                 Expression * argExpr = i->expr->clone();
    843                                 if ( argExpr->get_result()->size() > 1 && ! castExpr->get_result()->isVoid() ) {
    844                                         // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
    845                                         // to its corresponding target type, producing the tuple of those cast expressions. If there are
    846                                         // more components of the tuple than components in the target type, then excess components do not
    847                                         // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
    848                                         if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
    849                                                 // expressions which may contain side effects require a single unique instance of the expression.
    850                                                 argExpr = new UniqueExpr( argExpr );
    851                                         }
    852                                         std::list< Expression * > componentExprs;
    853                                         for ( unsigned int i = 0; i < castExpr->get_result()->size(); i++ ) {
    854                                                 // cast each component
    855                                                 TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
    856                                                 componentExprs.push_back( new CastExpr( idx, castExpr->get_result()->getComponent( i )->clone() ) );
    857                                         }
    858                                         delete argExpr;
    859                                         assert( componentExprs.size() > 0 );
    860                                         // produce the tuple of casts
    861                                         candidates.push_back( Alternative( new TupleExpr( componentExprs ), i->env, i->cost, thisCost ) );
    862                                 } else {
    863                                         // handle normally
    864                                         candidates.push_back( Alternative( new CastExpr( argExpr->clone(), toType->clone() ), i->env, i->cost, thisCost ) );
    865                                 }
     868                                candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
    866869                        } // if
    867870                } // for
     
    11831186
    11841187        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                // handle each option like a cast
    11881189                AltList candidates;
    1189                 std::cerr << "untyped init expr: " << initExpr << std::endl;
     1190                PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; )
    11901191                // O(N^2) checks of d-types with e-types
    1191                 for ( Alternative & alt : finder.get_alternatives() ) {
    1192                         for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
     1192                for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
     1193                        Type * toType = resolveTypeof( initAlt.type, indexer );
     1194                        SymTab::validateType( toType, &indexer );
     1195                        adjustExprType( toType, env, indexer );
     1196                        // Ideally the call to findWithAdjustment could be moved out of the loop, but unfortunately it currently has to occur inside or else
     1197                        // polymorphic return types are not properly bound to the initialization type, since return type variables are only open for the duration of resolving
     1198                        // the UntypedExpr. This is only actually an issue in initialization contexts that allow more than one possible initialization type, but it is still suboptimal.
     1199                        AlternativeFinder finder( indexer, env );
     1200                        finder.targetType = toType;
     1201                        finder.findWithAdjustment( initExpr->get_expr() );
     1202                        for ( Alternative & alt : finder.get_alternatives() ) {
     1203                                TypeEnvironment newEnv( alt.env );
    11931204                                AssertionSet needAssertions, haveAssertions;
    1194                                 OpenVarSet openVars;
    1195                                 std::cerr << "  " << initAlt.type << " " << initAlt.designation << std::endl;
     1205                                OpenVarSet openVars;  // find things in env that don't have a "representative type" and claim those are open vars?
     1206                                PRINT( std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl; )
    11961207                                // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
    11971208                                // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
    11981209                                // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
    11991210                                // to.
    1200                                 int discardedValues = alt.expr->get_result()->size() - initAlt.type->size();
     1211                                int discardedValues = alt.expr->get_result()->size() - toType->size();
    12011212                                if ( discardedValues < 0 ) continue;
    12021213                                // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
    12031214                                // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
    12041215                                // 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 );
     1216                                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??
     1217
     1218                                Cost thisCost = castCost( alt.expr->get_result(), toType, indexer, newEnv );
    12081219                                if ( thisCost != Cost::infinity ) {
    12091220                                        // count one safe conversion for each value that is thrown away
    12101221                                        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 ) );
     1222                                        candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
    12121223                                }
    12131224                        }
  • src/ResolvExpr/CurrentObject.cc

    rbb1cd95 r6242335  
    2222#include "SynTree/Initializer.h"
    2323#include "SynTree/Type.h"
     24#include "SynTree/TypeSubstitution.h"
    2425
    2526#if 0
     
    3233        long long int getConstValue( ConstantExpr * constExpr ) {
    3334                if ( BasicType * basicType = dynamic_cast< BasicType * >( constExpr->get_result() ) ) {
    34                         if ( basicType->get_kind() == BasicType::Char || basicType->get_kind() == BasicType::SignedChar || basicType->get_kind() == BasicType::UnsignedChar ) {
    35                                 assertf( constExpr->get_constant()->get_value().size() == 3, "constant value with unusual length: %s", constExpr->get_constant()->get_value().c_str() );
    36                                 return constExpr->get_constant()->get_value()[1];
     35                        if ( basicType->isInteger() ) {
     36                                return constExpr->get_constant()->get_ival();
    3737                        } else {
    38                                 return stoll( constExpr->get_constant()->get_value() );
    39                         }
     38                                assertf( false, "Non-integer constant expression in getConstValue", toString( constExpr ).c_str() ); // xxx - might be semantic error
     39                        }
     40                } else if ( dynamic_cast< OneType * >( constExpr->get_result() ) ) {
     41                        return 1;
     42                } else if ( dynamic_cast< ZeroType * >( constExpr->get_result() ) ) {
     43                        return 0;
    4044                } else {
    41                         assertf( false, "unhandled type on getConstValue %s", constExpr->get_result() );
     45                        assertf( false, "unhandled type on getConstValue %s", toString( constExpr->get_result() ).c_str() ); // xxx - might be semantic error
    4246                }
    4347        }
     
    5660        std::ostream & operator<<( std::ostream & out, Indenter & indent ) {
    5761                return out << std::string(indent.indent, ' ');
     62        }
     63
     64        template< typename AggrInst >
     65        TypeSubstitution makeGenericSubstitution( AggrInst * inst ) {
     66                assert( inst );
     67                assert( inst->get_baseParameters() );
     68                std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
     69                std::list< Expression * > typeSubs = inst->get_parameters();
     70                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
     71                return subs;
     72        }
     73
     74        TypeSubstitution makeGenericSubstitution( Type * type ) {
     75                if ( StructInstType * inst = dynamic_cast< StructInstType * >( type ) ) {
     76                        return makeGenericSubstitution( inst );
     77                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( type ) ) {
     78                        return makeGenericSubstitution( inst );
     79                } else {
     80                        return TypeSubstitution();
     81                }
    5882        }
    5983
     
    135159                void setSize( Expression * expr ) {
    136160                        if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
    137                                 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
     161                                size = getConstValue( constExpr );
    138162                                PRINT( std::cerr << "array type with size: " << size << std::endl; )
    139163                        }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
    140                                 setSize( castExpr->get_arg() );
     164                                setSize( castExpr->get_arg() ); // xxx - need to perform the conversion specified by the cast
    141165                        } else {
    142                                 assertf( false, "unhandled expression in setSize: %s", toString( expr ).c_str() );
     166                                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
    143167                        }
    144168                }
     
    231255        class AggregateIterator : public MemberIterator {
    232256        public:
    233                 typedef std::list<Declaration *>::iterator iterator;
    234                 const char * kind = ""; // for debug
    235                 ReferenceToType * inst = nullptr;
    236                 AggregateDecl * decl = nullptr;
     257                typedef std::list<Declaration *> MemberList;
     258                typedef MemberList::const_iterator iterator;
     259                std::string kind = ""; // for debug
     260                std::string name;
     261                Type * inst = nullptr;
     262                const MemberList & members;
    237263                iterator curMember;
    238                 bool atbegin = true; // false at first {small,big}Step -- this struct type is only added to the possibilities at the beginning
     264                bool atbegin = true; // false at first {small,big}Step -- this aggr type is only added to the possibilities at the beginning
    239265                Type * curType = nullptr;
    240266                MemberIterator * memberIter = nullptr;
    241 
    242                 AggregateIterator( const char * kind, ReferenceToType * inst, AggregateDecl * decl ) : kind( kind ), inst( inst ), decl( decl ), curMember( decl->get_members().begin() ) {
     267                mutable TypeSubstitution sub;
     268
     269                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 ) ) {
    243270                        init();
    244271                }
     
    249276
    250277                bool init() {
    251                         PRINT( std::cerr << "--init()--" << std::endl; )
    252                         if ( curMember != decl->get_members().end() ) {
     278                        PRINT( std::cerr << "--init()--" << members.size() << std::endl; )
     279                        if ( curMember != members.end() ) {
    253280                                if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( *curMember ) ) {
    254281                                        PRINT( std::cerr << "incremented to field: " << field << std::endl; )
     
    264291                        if (memberIter && *memberIter) {
    265292                                std::list<InitAlternative> ret = memberIter->first();
     293                                PRINT( std::cerr << "sub: " << sub << std::endl; )
    266294                                for ( InitAlternative & alt : ret ) {
    267295                                        PRINT( std::cerr << "iterating and adding designators" << std::endl; )
    268296                                        alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) );
     297                                        // need to substitute for generic types, so that casts are to concrete types
     298                                        PRINT( std::cerr << "  type is: " << alt.type; )
     299                                        sub.apply( alt.type ); // also apply to designation??
     300                                        PRINT( std::cerr << " ==> " << alt.type << std::endl; )
    269301                                }
    270302                                return ret;
     
    276308                        if ( ! designators.empty() ) {
    277309                                if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( designators.front() ) ) {
    278                                         for ( curMember = decl->get_members().begin(); curMember != decl->get_members().end(); ++curMember ) {
     310                                        for ( curMember = members.begin(); curMember != members.end(); ++curMember ) {
    279311                                                if ( *curMember == varExpr->get_var() ) {
    280312                                                        designators.pop_front();
     
    282314                                                        memberIter = createMemberIterator( varExpr->get_result() );
    283315                                                        curType = varExpr->get_result();
    284                                                         atbegin = curMember == decl->get_members().begin() && designators.empty(); // xxx - is this right??
     316                                                        atbegin = curMember == members.begin() && designators.empty(); // xxx - is this the right condition for atbegin??
    285317                                                        memberIter->setPosition( designators );
    286318                                                        return;
    287319                                                } // if
    288320                                        } // for
    289                                         assertf( false, "could not find member in %s: %s", kind, toString( varExpr ).c_str() );
     321                                        assertf( false, "could not find member in %s: %s", kind.c_str(), toString( varExpr ).c_str() );
    290322                                } else {
    291                                         assertf( false, "bad designator given to %s: %s", kind, toString( designators.front() ).c_str() );
     323                                        assertf( false, "bad designator given to %s: %s", kind.c_str(), toString( designators.front() ).c_str() );
    292324                                } // if
    293325                        } // if
     
    336368
    337369                virtual void print( std::ostream & out, Indenter indent ) const {
    338                         out << kind << "(" << decl->get_name() << ")";
     370                        out << kind << "(" << name << ")";
    339371                        if ( memberIter ) {
    340372                                Indenter childIndent = indent+1;
     
    347379        class UnionIterator : public AggregateIterator {
    348380        public:
    349                 UnionIterator( UnionInstType * inst ) : AggregateIterator( "UnionIterator", inst, inst->get_baseUnion() ) {}
     381                UnionIterator( UnionInstType * inst ) : AggregateIterator( "UnionIterator", inst->get_name(), inst, inst->get_baseUnion()->get_members() ) {}
    350382
    351383                virtual operator bool() const { return (memberIter && *memberIter); }
     
    357389                        memberIter = nullptr;
    358390                        curType = nullptr;
    359                         curMember = decl->get_members().end();
     391                        curMember = members.end();
    360392                        return *this;
    361393                }
     
    365397        class StructIterator : public AggregateIterator {
    366398        public:
    367                 StructIterator( StructInstType * inst ) : AggregateIterator( "StructIterator", inst, inst->get_baseStruct() ) {}
    368 
    369                 virtual operator bool() const { return curMember != decl->get_members().end() || (memberIter && *memberIter); }
     399                StructIterator( StructInstType * inst ) : AggregateIterator( "StructIterator", inst->get_name(), inst, inst->get_baseStruct()->get_members() ) {}
     400
     401                virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); }
    370402
    371403                virtual MemberIterator & bigStep() {
     
    375407                        memberIter = nullptr;
    376408                        curType = nullptr;
    377                         for ( ; curMember != decl->get_members().end(); ) {
     409                        for ( ; curMember != members.end(); ) {
     410                                ++curMember;
     411                                if ( init() ) {
     412                                        return *this;
     413                                }
     414                        }
     415                        return *this;
     416                }
     417        };
     418
     419        class TupleIterator : public AggregateIterator {
     420        public:
     421                TupleIterator( TupleType * inst ) : AggregateIterator( "TupleIterator", toString("Tuple", inst->size()), inst, inst->get_members() ) {}
     422
     423                virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); }
     424
     425                virtual MemberIterator & bigStep() {
     426                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
     427                        atbegin = false;
     428                        delete memberIter;
     429                        memberIter = nullptr;
     430                        curType = nullptr;
     431                        for ( ; curMember != members.end(); ) {
    378432                                ++curMember;
    379433                                if ( init() ) {
     
    392446                                return new UnionIterator( uit );
    393447                        } else {
    394                                 assertf( false, "some other reftotype" );
     448                                assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype" );
     449                                return new SimpleIterator( type );
    395450                        }
    396451                } else if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
    397452                        return new ArrayIterator( at );
     453                } else if ( TupleType * tt = dynamic_cast< TupleType * >( type ) ) {
     454                        return new TupleIterator( tt );
    398455                } else {
    399456                        return new SimpleIterator( type );
     
    494551                Type * type = objStack.top()->getNext();
    495552                if ( type ) {
    496                         // xxx - record types.front()?
    497553                        objStack.push( createMemberIterator( type ) );
    498554                } else {
     
    517573                return **objStack.top();
    518574        }
     575
     576        Type * CurrentObject::getCurrentType() {
     577                PRINT( std::cerr << "____getting current type" << std::endl; )
     578                assertf( ! objStack.empty(), "objstack empty in getCurrentType" );
     579                return objStack.top()->getNext();
     580        }
    519581} // namespace ResolvExpr
    520582
  • src/ResolvExpr/CurrentObject.h

    rbb1cd95 r6242335  
    4242                /// produces a list of alternatives (Type *, Designation *) for the current sub-object's initializer
    4343                std::list< InitAlternative > getOptions();
     44                /// produces the type of the current object but no subobjects
     45                Type * getCurrentType();
    4446
    4547        private:
  • src/ResolvExpr/Resolver.cc

    rbb1cd95 r6242335  
    375375        }
    376376
    377         template< typename Aggr >
    378         void lookupDesignation( Aggr * aggr, const std::list< Expression > & designators ) {
    379 
    380         }
    381 
    382377        void Resolver::visit( SingleInit *singleInit ) {
     378                // resolve initialization using the possibilities as determined by the currentObject cursor
    383379                UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
    384380                Expression * newExpr = findSingleExpression( untyped, *this );
    385381                InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
    386                 singleInit->set_value( new CastExpr( initExpr->get_expr()->clone(), initExpr->get_result()->clone() ) );
     382
     383                // move cursor to the object that is actually initialized
    387384                currentObject.setNext( initExpr->get_designation() );
     385
     386                // discard InitExpr wrapper and retain relevant pieces
     387                newExpr = initExpr->get_expr();
     388                singleInit->get_value()->set_env( initExpr->get_env() );
     389                initExpr->set_expr( nullptr );
     390                initExpr->set_env( nullptr );
     391                delete initExpr;
     392
     393                // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
     394                Type * initContext = currentObject.getCurrentType();
     395
     396                // check if actual object's type is char[]
     397                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
     398                        if ( isCharType( at->get_base() ) ) {
     399                                // check if the resolved type is char *
     400                                if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
     401                                        if ( isCharType( pt->get_base() ) ) {
     402                                                // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
     403                                                CastExpr *ce = safe_dynamic_cast< CastExpr * >( newExpr );
     404                                                newExpr = ce->get_arg();
     405                                                ce->set_arg( nullptr );
     406                                                delete ce;
     407                                        }
     408                                }
     409                        }
     410                }
     411
     412                // set initializer expr to resolved express
     413                singleInit->set_value( newExpr );
     414
     415                // move cursor to next object in preparation for next initializer
    388416                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         // }
     417        }
    470418
    471419        void Resolver::visit( ListInit * listInit ) {
     420                // move cursor into brace-enclosed initializer-list
    472421                currentObject.enterListInit();
    473422                // xxx - fix this so that the list isn't copied, iterator should be used to change current element
    474423                std::list<Designation *> newDesignations;
    475424                for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
     425                        // iterate designations and initializers in pairs, moving the cursor to the current designated object and resolving
     426                        // the initializer against that object.
    476427                        Designation * des = std::get<0>(p);
    477428                        Initializer * init = std::get<1>(p);
     
    479430                        init->accept( *this );
    480431                }
     432                // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
    481433                listInit->get_designations() = newDesignations; // xxx - memory management
    482434                currentObject.exitListInit();
    483435
     436                // xxx - this part has not be folded into CurrentObject yet
    484437                // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
    485438                //      Type * base = tt->get_baseType()->get_base();
  • src/ResolvExpr/Unify.cc

    rbb1cd95 r6242335  
    606606                        } else if ( tupleParam ) {
    607607                                // bundle other parameters into tuple to match
    608                                 TupleType* binder = new TupleType{ paramTy->get_qualifiers() };
     608                                std::list< Type * > binderTypes;
    609609
    610610                                do {
    611                                         binder->get_types().push_back( otherParam->get_type()->clone() );
     611                                        binderTypes.push_back( otherParam->get_type()->clone() );
    612612                                        ++jt;
    613613
     
    618618                                } while (true);
    619619
    620                                 otherParamTy = binder;
     620                                otherParamTy = new TupleType{ paramTy->get_qualifiers(), binderTypes };
    621621                                ++it;  // skip ttype parameter for break
    622622                        } else if ( otherTupleParam ) {
    623623                                // bundle parameters into tuple to match other
    624                                 TupleType* binder = new TupleType{ otherParamTy->get_qualifiers() };
     624                                std::list< Type * > binderTypes;
    625625
    626626                                do {
    627                                         binder->get_types().push_back( param->get_type()->clone() );
     627                                        binderTypes.push_back( param->get_type()->clone() );
    628628                                        ++it;
    629629
     
    634634                                } while (true);
    635635
    636                                 paramTy = binder;
     636                                paramTy = new TupleType{ otherParamTy->get_qualifiers(), binderTypes };
    637637                                ++jt;  // skip ttype parameter for break
    638638                        }
     
    756756                        return function->get_returnVals().front()->get_type()->clone();
    757757                } else {
    758                         TupleType * tupleType = new TupleType( Type::Qualifiers() );
     758                        std::list< Type * > types;
    759759                        for ( DeclarationWithType * decl : function->get_returnVals() ) {
    760                                 tupleType->get_types().push_back( decl->get_type()->clone() );
     760                                types.push_back( decl->get_type()->clone() );
    761761                        } // for
    762                         return tupleType;
     762                        return new TupleType( Type::Qualifiers(), types );
    763763                }
    764764        }
  • src/SymTab/ImplementationType.cc

    rbb1cd95 r6242335  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ImplementationType.cc -- 
     7// ImplementationType.cc --
    88//
    99// Author           : Richard C. Bilson
     
    9292
    9393        void ImplementationType::visit(TupleType *tupleType) {
    94                 TupleType *newType = new TupleType( Type::Qualifiers() );
     94                std::list< Type * > types;
    9595                for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) {
    9696                        Type *implType = implementationType( *i, indexer );
    9797                        implType->get_qualifiers() |= tupleType->get_qualifiers();
    98                         newType->get_types().push_back( implType );
     98                        types.push_back( implType );
    9999                } // for
    100                 result = newType;
     100                result = new TupleType( Type::Qualifiers(), types );
    101101        }
    102102
  • src/SynTree/Constant.cc

    rbb1cd95 r6242335  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Constant.cc -- 
     7// Constant.cc --
    88//
    99// Author           : Richard C. Bilson
     
    4646}
    4747
     48unsigned long long Constant::get_ival() const {
     49        assertf( safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );
     50        return val.ival;
     51}
     52
     53double Constant::get_dval() const {
     54        assertf( ! safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." );
     55        return val.dval;
     56}
     57
    4858void Constant::print( std::ostream &os ) const {
    4959        os << "(" << rep << " " << val.ival;
  • src/SynTree/Constant.h

    rbb1cd95 r6242335  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Constant.h -- 
     7// Constant.h --
    88//
    99// Author           : Richard C. Bilson
     
    3232        std::string & get_value() { return rep; }
    3333        void set_value( std::string newValue ) { rep = newValue; }
     34        unsigned long long get_ival() const;
     35        double get_dval() const;
    3436
    3537        /// generates a boolean constant of the given bool
  • src/SynTree/Expression.cc

    rbb1cd95 r6242335  
    2121#include <iterator>
    2222
     23#include "Declaration.h"
     24#include "Expression.h"
     25#include "Initializer.h"
     26#include "Statement.h"
    2327#include "Type.h"
    24 #include "Initializer.h"
    25 #include "Expression.h"
    26 #include "Declaration.h"
    27 #include "Statement.h"
    2828#include "TypeSubstitution.h"
     29#include "VarExprReplacer.h"
     30
    2931#include "Common/utility.h"
     32#include "Common/PassVisitor.h"
     33
    3034#include "InitTweak/InitTweak.h"
    3135
     
    681685}
    682686
    683 InitExpr::InitExpr( Expression * expr, Type * type, Designation * designation ) : expr( expr ), designation( designation ) {
    684         set_result( type );
     687InitExpr::InitExpr( Expression * expr, Designation * designation ) : expr( expr ), designation( designation ) {
     688        set_result( expr->get_result()->clone() );
    685689}
    686690InitExpr::InitExpr( const InitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), designation( maybeClone( other.designation) ) {}
  • src/SynTree/Expression.h

    rbb1cd95 r6242335  
    776776class InitExpr : public Expression {
    777777public:
    778         InitExpr( Expression * expr, Type * type, Designation * designation );
     778        InitExpr( Expression * expr, Designation * designation );
    779779        InitExpr( const InitExpr & other );
    780780        ~InitExpr();
  • src/SynTree/Initializer.cc

    rbb1cd95 r6242335  
    6565
    6666
    67 ListInit::ListInit( const std::list<Initializer*> &initializers, const std::list<Designation *> &designations, bool maybeConstructed )
    68         : Initializer( maybeConstructed ), initializers( initializers ), designations( designations ) {
     67ListInit::ListInit( const std::list<Initializer*> &inits, const std::list<Designation *> &des, bool maybeConstructed )
     68        : Initializer( maybeConstructed ), initializers( inits ), designations( des ) {
     69                // 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
     70                if ( designations.empty() ) {
     71                        for ( auto & i : initializers ) {
     72                                (void)i;
     73                                designations.push_back( new Designation( {} ) );
     74                        }
     75                }
     76                assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%d) and designations (%d)", initializers.size(), designations.size() );
    6977}
    7078
  • src/SynTree/Mutator.cc

    rbb1cd95 r6242335  
    515515        mutateAll( tupleType->get_forall(), *this );
    516516        mutateAll( tupleType->get_types(), *this );
     517        mutateAll( tupleType->get_members(), *this );
    517518        return tupleType;
    518519}
  • src/SynTree/TupleType.cc

    rbb1cd95 r6242335  
    1414//
    1515
     16#include "Declaration.h"
     17#include "Initializer.h"
    1618#include "Type.h"
    1719#include "Common/utility.h"
     20#include "Parser/LinkageSpec.h"
    1821
    1922TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) {
     23        for ( Type * t : *this ) {
     24                // 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
     25                // they end up getting constructors, which end up being inserted causing problems. This happens because the object decls have to be visited so that
     26                // 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
     27                // 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
     28                // object is visited, it is never constructed. Ultimately, a better solution might be either:
     29                // a) to separate TupleType from its declarations, into TupleDecl and Tuple{Inst?}Type, ala StructDecl and StructInstType
     30                // b) separate initializer nodes better, e.g. add a MaybeConstructed node that is replaced by genInit, rather than what currently exists in a bool
     31                members.push_back( new ObjectDecl( "" , Type::StorageClasses(), LinkageSpec::Cforall, nullptr, t->clone(), new ListInit( {}, {}, false ) ) );
     32        }
    2033}
    2134
    2235TupleType::TupleType( const TupleType& other ) : Type( other ) {
    2336        cloneAll( other.types, types );
     37        cloneAll( other.members, members );
    2438}
    2539
    2640TupleType::~TupleType() {
    2741        deleteAll( types );
     42        deleteAll( members );
    2843}
    2944
  • src/SynTree/Type.h

    rbb1cd95 r6242335  
    481481class TupleType : public Type {
    482482  public:
    483         TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     483        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    484484        TupleType( const TupleType& );
    485485        virtual ~TupleType();
     
    488488        typedef value_type::iterator iterator;
    489489
    490         std::list<Type*>& get_types() { return types; }
     490        std::list<Type *> & get_types() { return types; }
    491491        virtual unsigned size() const { return types.size(); };
     492
     493        // For now, this is entirely synthetic -- tuple types always have unnamed members.
     494        // Eventually, we may allow named tuples, in which case members should subsume types
     495        std::list<Declaration *> & get_members() { return members; }
    492496
    493497        iterator begin() { return types.begin(); }
     
    506510        virtual void print( std::ostream & os, int indent = 0 ) const;
    507511  private:
    508         std::list<Type*> types;
     512        std::list<Type *> types;
     513        std::list<Declaration *> members;
    509514};
    510515
  • src/SynTree/VarExprReplacer.cc

    rbb1cd95 r6242335  
    1414//
    1515
     16#include "Declaration.h"
    1617#include "Expression.h"
    1718#include "VarExprReplacer.h"
    1819
    19 VarExprReplacer::VarExprReplacer( const DeclMap & declMap ) : declMap( declMap ) {}
     20VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {}
    2021
    2122// replace variable with new node from decl map
    2223void VarExprReplacer::visit( VariableExpr * varExpr ) {
    23   // 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)
    24   if ( declMap.count( varExpr->get_var() ) ) {
    25     varExpr->set_var( declMap.at( varExpr->get_var() ) );
    26   }
     24        // 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)
     25        if ( declMap.count( varExpr->get_var() ) ) {
     26                if ( debug ) {
     27                        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;
     28                }
     29                varExpr->set_var( declMap.at( varExpr->get_var() ) );
     30        }
    2731}
  • src/SynTree/VarExprReplacer.h

    rbb1cd95 r6242335  
    2727private:
    2828        const DeclMap & declMap;
     29  bool debug;
    2930public:
    30         VarExprReplacer( const DeclMap & declMap );
     31        VarExprReplacer( const DeclMap & declMap, bool debug = false );
    3132
    3233        // replace variable with new node from decl map
  • src/SynTree/Visitor.cc

    rbb1cd95 r6242335  
    407407        acceptAll( tupleType->get_forall(), *this );
    408408        acceptAll( tupleType->get_types(), *this );
     409        acceptAll( tupleType->get_members(), *this );
    409410}
    410411
  • src/Tuples/TupleExpansion.cc

    rbb1cd95 r6242335  
    310310        Type * makeTupleType( const std::list< Expression * > & exprs ) {
    311311                // produce the TupleType which aggregates the types of the exprs
    312                 TupleType *tupleType = new TupleType( Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ) );
    313                 Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
     312                std::list< Type * > types;
     313                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex );
    314314                for ( Expression * expr : exprs ) {
    315315                        assert( expr->get_result() );
    316316                        if ( expr->get_result()->isVoid() ) {
    317317                                // if the type of any expr is void, the type of the entire tuple is void
    318                                 delete tupleType;
    319318                                return new VoidType( Type::Qualifiers() );
    320319                        }
    321320                        Type * type = expr->get_result()->clone();
    322                         tupleType->get_types().push_back( type );
     321                        types.push_back( type );
    323322                        // the qualifiers on the tuple type are the qualifiers that exist on all component types
    324323                        qualifiers &= type->get_qualifiers();
    325324                } // for
    326325                if ( exprs.empty() ) qualifiers = Type::Qualifiers();
    327                 return tupleType;
     326                return new TupleType( qualifiers, types );
    328327        }
    329328
  • src/tests/designations.c

    rbb1cd95 r6242335  
    2626const int indentAmt = 2;
    2727void indent(int level) {
    28   for (int i = 0; i < level; ++i) {
    29     printf(" ");
    30   }
     28        for (int i = 0; i < level; ++i) {
     29                printf(" ");
     30        }
    3131}
    3232
    3333// A contains fields with different types (int vs. int *)
    3434struct A {
    35   int x, y;
    36   int * ptr;
     35        int x, y;
     36        int * ptr;
    3737};
    3838void printA(struct A a, int level) {
    39   indent(level);
    40   printf("(A){ %d %d %p }\n", a.x, a.y, a.ptr);
     39        indent(level);
     40        printf("(A){ %d %d %p }\n", a.x, a.y, a.ptr);
    4141}
    4242
    4343// B contains struct members
    4444struct B {
    45   struct A a0, a1;
     45        struct A a0, a1;
    4646};
    4747void printB(struct B b, int level) {
    48   indent(level);
    49   printf("(B){\n");
    50   printA(b.a0, level+indentAmt);
    51   printA(b.a1, level+indentAmt);
    52   indent(level);
    53   printf("}\n");
     48        indent(level);
     49        printf("(B){\n");
     50        printA(b.a0, level+indentAmt);
     51        printA(b.a1, level+indentAmt);
     52        indent(level);
     53        printf("}\n");
    5454}
    5555
    5656// C contains an array - tests that after 3 ints, the members of B are initialized.
    5757struct C {
    58   int arr[3];
    59   struct B b;
     58        int arr[3];
     59        struct B b;
    6060};
    6161void printC(struct C c, int level) {
    62   indent(level);
    63   printf("(C){\n");
    64   indent(level+indentAmt);
    65   printf("(int[]{ %d %d %d }\n", c.arr[0], c.arr[1], c.arr[2]);
    66   printB(c.b, level+indentAmt);
    67   indent(level);
    68   printf("}\n");
     62        indent(level);
     63        printf("(C){\n");
     64        indent(level+indentAmt);
     65        printf("(int[]{ %d %d %d }\n", c.arr[0], c.arr[1], c.arr[2]);
     66        printB(c.b, level+indentAmt);
     67        indent(level);
     68        printf("}\n");
    6969}
    7070
    7171// D contains an unnamed aggregate - tests that this doesn't interfere with initialization.
    7272struct D {
    73   struct {
    74     int x;
    75   };
     73        struct {
     74                int x;
     75        };
    7676};
    7777void printD(struct D d, int level) {
    78   indent(level);
    79   printf("(D){ %d }\n", d.x);
     78        indent(level);
     79        printf("(D){ %d }\n", d.x);
    8080}
    8181
    8282// E tests unions
    8383union E {
    84   struct A a;
    85   struct B b;
    86   struct C c;
    87   struct D d;
    88   int i;
     84        struct A a;
     85        struct B b;
     86        struct C c;
     87        struct D d;
     88        int i;
    8989};
    9090
    9191int main() {
    92   // simple designation case - starting from beginning of structure, leaves ptr default-initialized (zero)
    93   struct A y0 = {
    94         .x DES 2,
    95         .y DES 3
    96   };
    97 
    98   // simple initializaiton case - initialize all elements explicitly with no designations
    99   struct A y1 = {
    100     2, 3, 0
    101   };
    102 
    103 
    104   // use designation to move to member y, leaving x default-initialized (zero)
    105   struct A y2 = {
    106     .y DES 3,
    107     0
    108   };
     92        // simple designation case - starting from beginning of structure, leaves ptr default-initialized (zero)
     93        struct A y0 = {
     94                .x DES 2,
     95                .y DES 3
     96        };
     97
     98        // simple initializaiton case - initialize all elements explicitly with no designations
     99        struct A y1 = {
     100                2, 3, 0
     101        };
     102
     103
     104        // use designation to move to member y, leaving x default-initialized (zero)
     105        struct A y2 = {
     106                .y DES 3,
     107                0
     108        };
    109109
    110110#if ERROR
    111   struct A yErr0 = {
    112     {} // error - empty scalar initializer is illegal
    113   };
    114 #endif
    115 
    116   printf("=====A=====\n");
    117   printA(y0, 0);
    118   printA(y1, 0);
    119   printA(y2, 0);
    120   printf("=====A=====\n\n");
    121 
    122   // initialize only first element (z0.a.x), leaving everything else default-initialized (zero), no nested curly-braces
    123   struct B z0 = { 5 };
    124 
    125   // some nested curly braces, use designation to 'jump around' within structure, leaving some members default-initialized
    126   struct B z1 = {
    127     { 3 }, // z1.a0
    128     { 4 }, // z1.a1
    129     .a0 DES { 5 }, // z1.a0
    130     { 6 }, // z1.a1
    131     .a0.y DES 2, // z1.a0.y
    132     0, // z1.a0.ptr
    133   };
    134 
    135   // z2.a0.y and z2.a0.ptr default-initialized, everything else explicit
    136   struct B z2 = {
    137     { 1 },
    138     { 2, 3, 0 }
    139   };
    140 
    141   // initialize every member, omitting nested curly braces
    142   struct B z3 = {
    143     1, 2, 0, 4, 5, 0
    144   };
    145 
    146   // no initializer - legal C, but garbage values - don't print this one
    147   struct B z4;
    148 
    149   // no curly braces - initialize with object of same type
    150   struct B z5 = z2;
    151 
    152   // z6.a0.y and z6.a0.ptr default-initialized, everything else explicit.
    153   // no curly braces on z6.a1 initializers
    154   struct B z6 = {
    155     { 1 },
    156     2, 3, 0
    157   };
    158 
    159   printf("=====B=====\n");
    160   printB(z0, 0);
    161   printB(z1, 0);
    162   printB(z2, 0);
    163   printB(z3, 0);
    164   printB(z5, 0);
    165   printB(z6, 0);
    166   printf("=====B=====\n\n");
    167 
    168   // TODO: what about extra things in a nested init? are empty structs skipped??
    169 
    170   // test that initializing 'past array bound' correctly moves to next member.
    171   struct C c1 = {
    172     2, 3, 4,  // arr
    173     5, 6, 0,  // b.a0
    174     7, 8, 0,  // b.a1
    175   };
    176 
    177   printf("=====C=====\n");
    178   printC(c1, 0);
    179   printf("=====C=====\n\n");
     111        struct A yErr0 = {
     112                {} // error - empty scalar initializer is illegal
     113        };
     114#endif
     115
     116        printf("=====A=====\n");
     117        printA(y0, 0);
     118        printA(y1, 0);
     119        printA(y2, 0);
     120        printf("=====A=====\n\n");
     121
     122        // initialize only first element (z0.a.x), leaving everything else default-initialized (zero), no nested curly-braces
     123        struct B z0 = { 5 };
     124
     125        // some nested curly braces, use designation to 'jump around' within structure, leaving some members default-initialized
     126        struct B z1 = {
     127                { 3 }, // z1.a0
     128                { 4 }, // z1.a1
     129                .a0 DES { 5 }, // z1.a0
     130                { 6 }, // z1.a1
     131                .a0.y DES 2, // z1.a0.y
     132                0, // z1.a0.ptr
     133        };
     134
     135        // z2.a0.y and z2.a0.ptr default-initialized, everything else explicit
     136        struct B z2 = {
     137                { 1 },
     138                { 2, 3, 0 }
     139        };
     140
     141        // initialize every member, omitting nested curly braces
     142        struct B z3 = {
     143                1, 2, 0, 4, 5, 0
     144        };
     145
     146        // no initializer - legal C, but garbage values - don't print this one
     147        struct B z4;
     148
     149        // no curly braces - initialize with object of same type
     150        struct B z5 = z2;
     151
     152        // z6.a0.y and z6.a0.ptr default-initialized, everything else explicit.
     153        // no curly braces on z6.a1 initializers
     154        struct B z6 = {
     155                { 1 },
     156                2, 3, 0
     157        };
     158
     159        printf("=====B=====\n");
     160        printB(z0, 0);
     161        printB(z1, 0);
     162        printB(z2, 0);
     163        printB(z3, 0);
     164        printB(z5, 0);
     165        printB(z6, 0);
     166        printf("=====B=====\n\n");
     167
     168        // TODO: what about extra things in a nested init? are empty structs skipped??
     169
     170        // test that initializing 'past array bound' correctly moves to next member.
     171        struct C c1 = {
     172                2, 3, 4,  // arr
     173                5, 6, 0,  // b.a0
     174                7, 8, 0,  // b.a1
     175        };
     176
     177        printf("=====C=====\n");
     178        printC(c1, 0);
     179        printf("=====C=====\n\n");
    180180
    181181#if ERROR
    182   // nested initializer can't refer to same type in C
    183   struct C cErr0 = { c1 };
    184 
    185   // must use curly braces to initialize members
    186   struct C cErr1 = 2;
    187 
    188   // can't initialize with array compound literal
    189   struct C cErr2 = {
    190     (int[3]) { 1, 2, 3 }  // error: array initialized from non-constant array expression
    191   };
     182        // nested initializer can't refer to same type in C
     183        struct C cErr0 = { c1 };
     184
     185        // must use curly braces to initialize members
     186        struct C cErr1 = 2;
     187
     188        // can't initialize with array compound literal
     189        struct C cErr2 = {
     190                (int[3]) { 1, 2, 3 }  // error: array initialized from non-constant array expression
     191        };
    192192#endif
    193193
    194194#if WARNING
    195   // can't initialize array with array - converts to int*
    196   int cWarn0_arr[3] = { 1, 2, 3 };
    197   struct C cWarn0 = {
    198     cWarn0_arr  // warning: initialization makes integer from ptr without cast
    199   };
    200 #endif
    201 
    202   // allowed to have 'too many' initialized lists - essentially they are ignored.
    203   int i1 = { 3 };
    204 
    205   // doesn't work yet.
    206   // designate unnamed object's members
    207   // struct D d = { .x DES 3 };
     195        // can't initialize array with array - converts to int*
     196        int cWarn0_arr[3] = { 1, 2, 3 };
     197        struct C cWarn0 = {
     198                cWarn0_arr  // warning: initialization makes integer from ptr without cast
     199        };
     200#endif
     201
     202        // allowed to have 'too many' initialized lists - essentially they are ignored.
     203        int i1 = { 3 };
     204
     205        // doesn't work yet.
     206        // designate unnamed object's members
     207        // struct D d = { .x DES 3 };
    208208#if ERROR
    209   struct D d1 = { .y DES 3 };
    210 #endif
    211 
    212   // simple union initialization - initialized first member (e0.a)
    213   union E e0 = {
    214     y0
    215   };
    216 
    217   // simple union initialization - initializes first member (e1.a) - with nested initializer list
    218   union E e1 = {
    219     { 2, 3, 0 }
    220   };
    221 
    222   // simple union initialization - initializes first member (e2.a) - without nested initializer list
    223   union E e2 = {
    224     2, 3, 0
    225   };
    226 
    227   // move cursor to e4.b.a0.x and initialize until e3.b.a1.ptr inclusive
    228   union E e3 = {
    229     .b.a0.x DES 2, 3, 0, 5, 6, 0
    230   };
    231 
    232   printf("=====E=====\n");
    233   printA(e0.a, 0);
    234   printA(e1.a, 0);
    235   printA(e2.a, 0);
    236   printB(e3.b, 0);
    237   printf("=====E=====\n\n");
     209        struct D d1 = { .y DES 3 };
     210#endif
     211
     212        // simple union initialization - initialized first member (e0.a)
     213        union E e0 = {
     214                y0
     215        };
     216
     217        // simple union initialization - initializes first member (e1.a) - with nested initializer list
     218        union E e1 = {
     219                { 2, 3, 0 }
     220        };
     221
     222        // simple union initialization - initializes first member (e2.a) - without nested initializer list
     223        union E e2 = {
     224                2, 3, 0
     225        };
     226
     227        // move cursor to e4.b.a0.x and initialize until e3.b.a1.ptr inclusive
     228        union E e3 = {
     229                .b.a0.x DES 2, 3, 0, 5, 6, 0
     230        };
     231
     232        printf("=====E=====\n");
     233        printA(e0.a, 0);
     234        printA(e1.a, 0);
     235        printA(e2.a, 0);
     236        printB(e3.b, 0);
     237        printf("=====E=====\n\n");
     238
     239        // special case of initialization: char[] can be initialized with a string literal
     240        const char * str0 = "hello";
     241        char str1[] = "hello";
    238242}
    239243
Note: See TracChangeset for help on using the changeset viewer.