Changeset e4d829b for src/SynTree

Timestamp:

Jun 20, 2017, 1:19:53 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

579263a

Parents:

c6d2e93

git-author:

Rob Schluntz <rschlunt@…> (06/20/17 13:16:13)

git-committer:

Rob Schluntz <rschlunt@…> (06/20/17 13:19:53)

Message:

major effort on designations, works in many cases

Location:

src/SynTree

Files:

• Expression.cc (modified) (2 diffs)
• Expression.h (modified) (1 diff)
• Initializer.cc (modified) (3 diffs)
• Initializer.h (modified) (7 diffs)
• Mutator.cc (modified) (3 diffs)
• Mutator.h (modified) (2 diffs)
• SynTree.h (modified) (2 diffs)
• Visitor.cc (modified) (3 diffs)
• Visitor.h (modified) (3 diffs)

src/SynTree/Expression.cc

@@ -92 +92 @@
 
         Declaration *decl = get_var();
-        // if ( decl != 0) decl->print(os, indent + 2);
         if ( decl != 0) decl->printShort(os, indent + 2);
         os << std::endl;
@@ -670 +669 @@
 }
 
+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<InitAlternative> & 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 ) {

src/SynTree/Expression.h

@@ -781 +781 @@
 };
 
+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<InitAlternative> & initAlts );
+        UntypedInitExpr( const UntypedInitExpr & other );
+        ~UntypedInitExpr();
+
+        Expression * get_expr() const { return expr; }
+        UntypedInitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+
+        std::list<InitAlternative> & 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<InitAlternative> 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 );
 

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() {}
 
-std::string Initializer::designator_name( Expression *des ) {
-        if ( NameExpr *n = dynamic_cast<NameExpr *>(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<Initializer*> &_initializers, const std::list<Expression *> &_designators, bool maybeConstructed )
-        : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) {
+
+ListInit::ListInit( const std::list<Initializer*> &initializers, const std::list<Designation *> &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<Initializer *>::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 +103 @@
 }
 
-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 +124 @@
 }
 
-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;
 }

src/SynTree/Initializer.h

@@ -25 +25 @@
 #include "Visitor.h"
 
-const std::list<Expression*> 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<Designation *> 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<Expression *> & ) { assert(false); }
-        virtual std::list<Expression *> &get_designators() {
-                assert(false);
-                std::list<Expression *> *ret = 0; return *ret;  // never reached
-        }
 
         bool get_maybeConstructed() { return maybeConstructed; }
@@ -53 +56 @@
         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 +64 @@
 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 +71 @@
         void set_value( Expression *newValue ) { value = newValue; }
 
-        std::list<Expression *> &get_designators() { return designators; }
-        void set_designators( std::list<Expression *> &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 +85 @@
   public:
         ListInit( const std::list<Initializer*> &initializers,
-                          const std::list<Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
+                          const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
         ListInit( const ListInit & other );
         virtual ~ListInit();
 
-        void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
-        std::list<Expression *> &get_designators() { return designators; }
-        void set_initializers( std::list<Initializer*> &newValue ) { initializers = newValue; }
-        std::list<Initializer*> &get_initializers() { return initializers; }
+        std::list<Designation *> & get_designations() { return designations; }
+        std::list<Initializer *> & get_initializers() { return initializers; }
 
         typedef std::list<Initializer*>::iterator iterator;
+        typedef std::list<Initializer*>::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<Initializer*> initializers;  // order *is* important
-        std::list<Expression *> designators;
+        std::list<Initializer *> initializers;  // order *is* important
+        std::list<Designation *> designations;  // order/length is consistent with initializers
 };
 
@@ -130 +128 @@
         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 +138 @@
 };
 
-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

src/SynTree/Mutator.cc

@@ -439 +439 @@
 }
 
+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 +557 @@
 
 
+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 +568 @@
 
 Initializer *Mutator::mutate( ListInit *listInit ) {
-        mutateAll( listInit->get_designators(), *this );
+        mutateAll( listInit->get_designations(), *this );
         mutateAll( listInit->get_initializers(), *this );
         return listInit;

src/SynTree/Mutator.h

@@ -86 +86 @@
         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 +106 @@
         virtual Type* mutate( OneType *oneType );
 
+        virtual Designation* mutate( Designation *designation );
         virtual Initializer* mutate( SingleInit *singleInit );
         virtual Initializer* mutate( ListInit *listInit );

src/SynTree/SynTree.h

@@ -93 +93 @@
 class StmtExpr;
 class UniqueExpr;
+class UntypedInitExpr;
+class InitExpr;
 
 class Type;
@@ -113 +115 @@
 class OneType;
 
+class Designation;
 class Initializer;
 class SingleInit;

src/SynTree/Visitor.cc

@@ -344 +344 @@
 }
 
+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 +440 @@
 }
 
+void Visitor::visit( Designation * designation ) {
+        acceptAll( designation->get_designators(), *this );
+}
 
 void Visitor::visit( SingleInit *singleInit ) {
@@ -434 +449 @@
 
 void Visitor::visit( ListInit *listInit ) {
-        acceptAll( listInit->get_designators(), *this );
+        acceptAll( listInit->get_designations(), *this );
         acceptAll( listInit->get_initializers(), *this );
 }

src/SynTree/Visitor.h

@@ -89 +89 @@
         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 +109 @@
         virtual void visit( OneType *oneType );
 
+        virtual void visit( Designation *designation );
         virtual void visit( SingleInit *singleInit );
         virtual void visit( ListInit *listInit );
@@ -163 +166 @@
                         } // if
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );                       
+                        e.set_location( (*i)->location );
                         errors.append( e );
                 } // try