Changes in src/SynTree/Initializer.cc [62423350:d7dc824]

File:

• src/SynTree/Initializer.cc (modified) (3 diffs)

src/SynTree/Initializer.cc

@@ -19 +19 @@
 #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() {}
 
-SingleInit::SingleInit( Expression *v, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ) {
+std::string Initializer::designator_name( Expression *des ) {
+        if ( NameExpr *n = dynamic_cast<NameExpr *>(des) )
+                return n->get_name();
+        else
+                throw 0;
+}
+
+// void Initializer::print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent ) {}
+
+SingleInit::SingleInit( Expression *v, const std::list< Expression *> &_designators, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ), designators( _designators ) {
 }
 
 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 ) const {
-        os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
+void SingleInit::print( std::ostream &os, int indent ) {
+        os << std::endl << 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<Initializer*> &inits, const std::list<Designation *> &des, bool maybeConstructed )
-        : Initializer( maybeConstructed ), initializers( inits ), designations( des ) {
-                // handle the common case where a ListInit is created without designations by making a list of empty designations with the same length as the initializer
-                if ( designations.empty() ) {
-                        for ( auto & i : initializers ) {
-                                (void)i;
-                                designations.push_back( new Designation( {} ) );
-                        }
-                }
-                assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%d) and designations (%d)", initializers.size(), designations.size() );
+ListInit::ListInit( const std::list<Initializer*> &_initializers, const std::list<Expression *> &_designators, bool maybeConstructed )
+        : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) {
 }
 
 ListInit::ListInit( const ListInit & other ) : Initializer( other ) {
         cloneAll( other.initializers, initializers );
-        cloneAll( other.designations, designations );
+        cloneAll( other.designators, designators );
 }
+
 
 ListInit::~ListInit() {
         deleteAll( initializers );
-        deleteAll( designations );
+        deleteAll( designators );
 }
 
-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 );
-        }
+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
 
-        for ( const Initializer * init : initializers ) {
-                init->print( os, indent + 2 );
-                os << std::endl;
-        }
+                os << std::string(indent + 2, ' ' ) << "]";
+        } // if
+
+        for ( std::list<Initializer *>::iterator i = initializers.begin(); i != initializers.end(); i++ )
+                (*i)->print( os, indent + 2 );
 }
 
@@ -110 +103 @@
 }
 
-void ConstructorInit::print( std::ostream &os, int indent ) const {
+void ConstructorInit::print( std::ostream &os, int indent ) {
         os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl;
         if ( ctor ) {
@@ -131 +124 @@
 }
 
-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";
-        }
+std::ostream & operator<<( std::ostream & out, Initializer * init ) {
+        init->print( out );
         return out;
 }