Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision 10e90cbfae38eadd2a8280da88fb0696174ffdda) +++ src/SynTree/Expression.cc (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -92,5 +92,4 @@ Declaration *decl = get_var(); - // if ( decl != 0) decl->print(os, indent + 2); if ( decl != 0) decl->printShort(os, indent + 2); os << std::endl; @@ -670,4 +669,46 @@ } +InitAlternative::InitAlternative( Type * type, Designation * designation ) : type( type ), designation( designation ) {} +InitAlternative::InitAlternative( const InitAlternative & other ) : type( maybeClone( other.type ) ), designation( maybeClone( other.designation ) ) {} +InitAlternative::~InitAlternative() { + delete type; + delete designation; +} + +UntypedInitExpr::UntypedInitExpr( Expression * expr, const std::list & initAlts ) : expr( expr ), initAlts( initAlts ) {} +UntypedInitExpr::UntypedInitExpr( const UntypedInitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), initAlts( other.initAlts ) {} +UntypedInitExpr::~UntypedInitExpr() { + delete expr; +} + +void UntypedInitExpr::print( std::ostream & os, int indent ) const { + os << "Untyped Init Expression" << std::endl << std::string( indent+2, ' ' ); + expr->print( os, indent+2 ); + if ( ! initAlts.empty() ) { + for ( const InitAlternative & alt : initAlts ) { + os << std::string( indent+2, ' ' ) << "InitAlternative: "; + alt.type->print( os, indent+2 ); + alt.designation->print( os, indent+2 ); + } + } +} + +InitExpr::InitExpr( Expression * expr, Type * type, Designation * designation ) : expr( expr ), designation( designation ) { + set_result( type ); +} +InitExpr::InitExpr( const InitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), designation( maybeClone( other.designation) ) {} +InitExpr::~InitExpr() { + delete expr; + delete designation; +} + +void InitExpr::print( std::ostream & os, int indent ) const { + os << "Init Expression" << std::endl << std::string( indent+2, ' ' ); + expr->print( os, indent+2 ); + os << std::string( indent+2, ' ' ) << "with designation: "; + designation->print( os, indent+2 ); +} + + std::ostream & operator<<( std::ostream & out, const Expression * expr ) { if ( expr ) { Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision 10e90cbfae38eadd2a8280da88fb0696174ffdda) +++ src/SynTree/Expression.h (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -781,4 +781,56 @@ }; +struct InitAlternative { +public: + Type * type = nullptr; + Designation * designation = nullptr; + InitAlternative( Type * type, Designation * designation ); + InitAlternative( const InitAlternative & other ); + InitAlternative & operator=( const Initializer & other ) = delete; // at the moment this isn't used, and I don't want to implement it + ~InitAlternative(); +}; + +class UntypedInitExpr : public Expression { +public: + UntypedInitExpr( Expression * expr, const std::list & initAlts ); + UntypedInitExpr( const UntypedInitExpr & other ); + ~UntypedInitExpr(); + + Expression * get_expr() const { return expr; } + UntypedInitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; } + + std::list & get_initAlts() { return initAlts; } + + virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * this ); } + virtual void accept( Visitor & v ) { v.visit( this ); } + virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); } + virtual void print( std::ostream & os, int indent = 0 ) const; +private: + Expression * expr; + std::list initAlts; +}; + +class InitExpr : public Expression { +public: + InitExpr( Expression * expr, Type * type, Designation * designation ); + InitExpr( const InitExpr & other ); + ~InitExpr(); + + Expression * get_expr() const { return expr; } + InitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; } + + Designation * get_designation() const { return designation; } + InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; } + + virtual InitExpr * clone() const { return new InitExpr( * this ); } + virtual void accept( Visitor & v ) { v.visit( this ); } + virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); } + virtual void print( std::ostream & os, int indent = 0 ) const; +private: + Expression * expr; + Designation * designation; +}; + + std::ostream & operator<<( std::ostream & out, const Expression * expr ); Index: src/SynTree/Initializer.cc =================================================================== --- src/SynTree/Initializer.cc (revision 10e90cbfae38eadd2a8280da88fb0696174ffdda) +++ src/SynTree/Initializer.cc (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -19,75 +19,75 @@ #include "Common/utility.h" +Designation::Designation( const std::list< Expression * > & designators ) : designators( designators ) {} +Designation::Designation( const Designation & other ) : BaseSyntaxNode( other ) { + // std::cerr << "cloning designation" << std::endl; + cloneAll( other.designators, designators ); + // std::cerr << "finished cloning designation" << std::endl; +} + +Designation::~Designation() { + // std::cerr << "destroying designation" << std::endl; + deleteAll( designators ); + // std::cerr << "finished destroying designation" << std::endl; +} + +void Designation::print( std::ostream &os, int indent ) const { + if ( ! designators.empty() ) { + os << std::string(indent + 2, ' ' ) << "designated by: " << std::endl; + for ( std::list < Expression * >::const_iterator i = designators.begin(); i != designators.end(); i++ ) { + os << std::string(indent + 4, ' ' ); + ( *i )->print(os, indent + 4 ); + } + os << std::endl; + } // if +} + + Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {} Initializer::Initializer( const Initializer & other ) : BaseSyntaxNode( other ), maybeConstructed( other.maybeConstructed ) { } - - Initializer::~Initializer() {} -std::string Initializer::designator_name( Expression *des ) { - if ( NameExpr *n = dynamic_cast(des) ) - return n->get_name(); - else - throw 0; -} - -void Initializer::print( std::ostream &os, int indent ) {} - -SingleInit::SingleInit( Expression *v, const std::list< Expression *> &_designators, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ), designators( _designators ) { +SingleInit::SingleInit( Expression *v, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ) { } SingleInit::SingleInit( const SingleInit &other ) : Initializer(other), value ( maybeClone( other.value ) ) { - cloneAll(other.designators, designators ); } SingleInit::~SingleInit() { delete value; - deleteAll(designators); } -void SingleInit::print( std::ostream &os, int indent ) { - os << std::endl << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl; +void SingleInit::print( std::ostream &os, int indent ) const { + os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl; os << std::string(indent+4, ' ' ); value->print( os, indent+4 ); - - if ( ! designators.empty() ) { - os << std::endl << std::string(indent + 2, ' ' ) << "designated by: " << std::endl; - for ( std::list < Expression * >::iterator i = designators.begin(); i != designators.end(); i++ ) { - os << std::string(indent + 4, ' ' ); - ( *i )->print(os, indent + 4 ); - } - } // if } -ListInit::ListInit( const std::list &_initializers, const std::list &_designators, bool maybeConstructed ) - : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) { + +ListInit::ListInit( const std::list &initializers, const std::list &designations, bool maybeConstructed ) + : Initializer( maybeConstructed ), initializers( initializers ), designations( designations ) { } ListInit::ListInit( const ListInit & other ) : Initializer( other ) { cloneAll( other.initializers, initializers ); - cloneAll( other.designators, designators ); + cloneAll( other.designations, designations ); } - ListInit::~ListInit() { deleteAll( initializers ); - deleteAll( designators ); + deleteAll( designations ); } -void ListInit::print( std::ostream &os, int indent ) { - os << std::endl << std::string(indent, ' ') << "Compound initializer: "; - if ( ! designators.empty() ) { - os << std::string(indent + 2, ' ' ) << "designated by: ["; - for ( std::list < Expression * >::iterator i = designators.begin(); - i != designators.end(); i++ ) { - ( *i )->print(os, indent + 4 ); - } // for +void ListInit::print( std::ostream &os, int indent ) const { + os << std::string(indent, ' ') << "Compound initializer: " << std::endl; + for ( Designation * d : designations ) { + d->print( os, indent + 2 ); + } - os << std::string(indent + 2, ' ' ) << "]"; - } // if - - for ( std::list::iterator i = initializers.begin(); i != initializers.end(); i++ ) - (*i)->print( os, indent + 2 ); + for ( const Initializer * init : initializers ) { + init->print( os, indent + 2 ); + os << std::endl; + } } @@ -103,5 +103,5 @@ } -void ConstructorInit::print( std::ostream &os, int indent ) { +void ConstructorInit::print( std::ostream &os, int indent ) const { os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl; if ( ctor ) { @@ -124,6 +124,19 @@ } -std::ostream & operator<<( std::ostream & out, Initializer * init ) { - init->print( out ); +std::ostream & operator<<( std::ostream & out, const Initializer * init ) { + if ( init ) { + init->print( out ); + } else { + out << "nullptr"; + } + return out; +} + +std::ostream & operator<<( std::ostream & out, const Designation * des ) { + if ( des ) { + des->print( out ); + } else { + out << "nullptr"; + } return out; } Index: src/SynTree/Initializer.h =================================================================== --- src/SynTree/Initializer.h (revision 10e90cbfae38eadd2a8280da88fb0696174ffdda) +++ src/SynTree/Initializer.h (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -25,26 +25,29 @@ #include "Visitor.h" -const std::list noDesignators; +// Designation: list of designator (NameExpr, VariableExpr, and ConstantExpr) expressions that specify an object being initialized. +class Designation : public BaseSyntaxNode { +public: + Designation( const std::list< Expression * > & designators ); + Designation( const Designation & other ); + virtual ~Designation(); + + std::list< Expression * > & get_designators() { return designators; } + + virtual Designation * clone() const { return new Designation( *this ); }; + virtual void accept( Visitor &v ) { v.visit( this ); } + virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); } + virtual void print( std::ostream &os, int indent = 0 ) const; +private: + std::list< Expression * > designators; +}; + +const std::list noDesignators; // Initializer: base class for object initializers (provide default values) class Initializer : public BaseSyntaxNode { public: - // Initializer( std::string _name = std::string(""), int _pos = 0 ); Initializer( bool maybeConstructed ); Initializer( const Initializer & other ); virtual ~Initializer(); - - static std::string designator_name( Expression *designator ); - - // void set_name( std::string newValue ) { name = newValue; } - // std::string get_name() const { return name; } - - // void set_pos( int newValue ) { pos = newValue; } - // int get_pos() const { return pos; } - virtual void set_designators( std::list & ) { assert(false); } - virtual std::list &get_designators() { - assert(false); - std::list *ret = 0; return *ret; // never reached - } bool get_maybeConstructed() { return maybeConstructed; } @@ -53,8 +56,6 @@ virtual void accept( Visitor &v ) = 0; virtual Initializer *acceptMutator( Mutator &m ) = 0; - virtual void print( std::ostream &os, int indent = 0 ); + virtual void print( std::ostream &os, int indent = 0 ) const = 0; private: - // std::string name; - // int pos; bool maybeConstructed; }; @@ -63,5 +64,5 @@ class SingleInit : public Initializer { public: - SingleInit( Expression *value, const std::list< Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false ); + SingleInit( Expression *value, bool maybeConstructed = false ); SingleInit( const SingleInit &other ); virtual ~SingleInit(); @@ -70,15 +71,11 @@ void set_value( Expression *newValue ) { value = newValue; } - std::list &get_designators() { return designators; } - void set_designators( std::list &newValue ) { designators = newValue; } - virtual SingleInit *clone() const { return new SingleInit( *this); } virtual void accept( Visitor &v ) { v.visit( this ); } virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os, int indent = 0 ); + virtual void print( std::ostream &os, int indent = 0 ) const; private: //Constant *value; Expression *value; // has to be a compile-time constant - std::list< Expression * > designators; }; @@ -88,24 +85,25 @@ public: ListInit( const std::list &initializers, - const std::list &designators = std::list< Expression * >(), bool maybeConstructed = false ); + const std::list &designators = {}, bool maybeConstructed = false ); ListInit( const ListInit & other ); virtual ~ListInit(); - void set_designators( std::list &newValue ) { designators = newValue; } - std::list &get_designators() { return designators; } - void set_initializers( std::list &newValue ) { initializers = newValue; } - std::list &get_initializers() { return initializers; } + std::list & get_designations() { return designations; } + std::list & get_initializers() { return initializers; } typedef std::list::iterator iterator; + typedef std::list::const_iterator const_iterator; iterator begin() { return initializers.begin(); } iterator end() { return initializers.end(); } + const_iterator begin() const { return initializers.begin(); } + const_iterator end() const { return initializers.end(); } virtual ListInit *clone() const { return new ListInit( *this ); } virtual void accept( Visitor &v ) { v.visit( this ); } virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os, int indent = 0 ); + virtual void print( std::ostream &os, int indent = 0 ) const; private: - std::list initializers; // order *is* important - std::list designators; + std::list initializers; // order *is* important + std::list designations; // order/length is consistent with initializers }; @@ -130,5 +128,5 @@ virtual void accept( Visitor &v ) { v.visit( this ); } virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os, int indent = 0 ); + virtual void print( std::ostream &os, int indent = 0 ) const; private: @@ -140,5 +138,6 @@ }; -std::ostream & operator<<( std::ostream & out, Initializer * init ); +std::ostream & operator<<( std::ostream & out, const Initializer * init ); +std::ostream & operator<<( std::ostream & out, const Designation * des ); #endif // INITIALIZER_H Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision 10e90cbfae38eadd2a8280da88fb0696174ffdda) +++ src/SynTree/Mutator.cc (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -439,4 +439,20 @@ } +Expression *Mutator::mutate( UntypedInitExpr * initExpr ) { + initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) ); + initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) ); + initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) ); + // not currently mutating initAlts, but this doesn't matter since this node is only used in the resolver. + return initExpr; +} + +Expression *Mutator::mutate( InitExpr * initExpr ) { + initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) ); + initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) ); + initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) ); + initExpr->set_designation( maybeMutate( initExpr->get_designation(), *this ) ); + return initExpr; +} + Type *Mutator::mutate( VoidType *voidType ) { @@ -541,4 +557,9 @@ +Designation *Mutator::mutate( Designation * designation ) { + mutateAll( designation->get_designators(), *this ); + return designation; +} + Initializer *Mutator::mutate( SingleInit *singleInit ) { singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) ); @@ -547,5 +568,5 @@ Initializer *Mutator::mutate( ListInit *listInit ) { - mutateAll( listInit->get_designators(), *this ); + mutateAll( listInit->get_designations(), *this ); mutateAll( listInit->get_initializers(), *this ); return listInit; Index: src/SynTree/Mutator.h =================================================================== --- src/SynTree/Mutator.h (revision 10e90cbfae38eadd2a8280da88fb0696174ffdda) +++ src/SynTree/Mutator.h (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -86,4 +86,6 @@ virtual Expression* mutate( StmtExpr * stmtExpr ); virtual Expression* mutate( UniqueExpr * uniqueExpr ); + virtual Expression* mutate( UntypedInitExpr * initExpr ); + virtual Expression* mutate( InitExpr * initExpr ); virtual Type* mutate( VoidType *basicType ); @@ -104,4 +106,5 @@ virtual Type* mutate( OneType *oneType ); + virtual Designation* mutate( Designation *designation ); virtual Initializer* mutate( SingleInit *singleInit ); virtual Initializer* mutate( ListInit *listInit ); Index: src/SynTree/SynTree.h =================================================================== --- src/SynTree/SynTree.h (revision 10e90cbfae38eadd2a8280da88fb0696174ffdda) +++ src/SynTree/SynTree.h (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -93,4 +93,6 @@ class StmtExpr; class UniqueExpr; +class UntypedInitExpr; +class InitExpr; class Type; @@ -113,4 +115,5 @@ class OneType; +class Designation; class Initializer; class SingleInit; Index: src/SynTree/Visitor.cc =================================================================== --- src/SynTree/Visitor.cc (revision 10e90cbfae38eadd2a8280da88fb0696174ffdda) +++ src/SynTree/Visitor.cc (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -344,4 +344,16 @@ } +void Visitor::visit( UntypedInitExpr * initExpr ) { + maybeAccept( initExpr->get_result(), *this ); + maybeAccept( initExpr->get_expr(), *this ); + // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver. +} + +void Visitor::visit( InitExpr * initExpr ) { + maybeAccept( initExpr->get_result(), *this ); + maybeAccept( initExpr->get_expr(), *this ); + maybeAccept( initExpr->get_designation(), *this ); +} + void Visitor::visit( VoidType *voidType ) { @@ -428,4 +440,7 @@ } +void Visitor::visit( Designation * designation ) { + acceptAll( designation->get_designators(), *this ); +} void Visitor::visit( SingleInit *singleInit ) { @@ -434,5 +449,5 @@ void Visitor::visit( ListInit *listInit ) { - acceptAll( listInit->get_designators(), *this ); + acceptAll( listInit->get_designations(), *this ); acceptAll( listInit->get_initializers(), *this ); } Index: src/SynTree/Visitor.h =================================================================== --- src/SynTree/Visitor.h (revision 10e90cbfae38eadd2a8280da88fb0696174ffdda) +++ src/SynTree/Visitor.h (revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768) @@ -89,4 +89,6 @@ virtual void visit( StmtExpr * stmtExpr ); virtual void visit( UniqueExpr * uniqueExpr ); + virtual void visit( UntypedInitExpr * initExpr ); + virtual void visit( InitExpr * initExpr ); virtual void visit( VoidType *basicType ); @@ -107,4 +109,5 @@ virtual void visit( OneType *oneType ); + virtual void visit( Designation *designation ); virtual void visit( SingleInit *singleInit ); virtual void visit( ListInit *listInit ); @@ -163,5 +166,5 @@ } // if } catch( SemanticError &e ) { - e.set_location( (*i)->location ); + e.set_location( (*i)->location ); errors.append( e ); } // try