Changeset 15934a6

Timestamp:

May 22, 2019, 1:10:58 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

4073b16, 74ad8c0

Parents:

9a0cd9c (diff), 9d23c2d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/Bitfield.hpp (modified) (1 diff)
• AST/Convert.cpp (modified) (7 diffs)
• AST/Expr.cpp (modified) (1 diff)
• AST/Expr.hpp (modified) (3 diffs)
• AST/Node.cpp (modified) (2 diffs)
• AST/Print.cpp (added)
• AST/Print.hpp (added)
• AST/module.mk (modified) (1 diff)
• Makefile.in (modified) (4 diffs)
• SynTree/Expression.h (modified) (1 diff)
• SynTree/TupleExpr.cc (modified) (1 diff)

src/AST/Bitfield.hpp

@@ -57 +57 @@
 };
 
-/// Adds default printing operator to a bitfield type.
-/// Include in definition to add print function, requires other bitfield operators.
-/// @param N  Number of bits in bitfield
-#define MakeBitfieldPrint( N ) \
-        static const char* Names[]; \
- \
-        void print( std::ostream & os ) const { \
-                if ( (*this).any() ) { \
-                        for ( unsigned int i = 0; i < N; i += 1 ) { \
-                                if ( (*this)[i] ) { \
-                                        os << Names[i] << ' '; \
-                                } \
-                        } \
-                } \
-        }
+template<typename T>
+inline bool operator== ( const bitfield<T> & a, const bitfield<T> & b ) {
+        return a.val == b.val;
+}
+
+template<typename T>
+inline bool operator!= ( const bitfield<T> & a, const bitfield<T> & b ) {
+        return !(a == b);
+}
 
 // Local Variables: //

src/AST/Convert.cpp

@@ -525 +525 @@
         }
 
+        Expression * visitBaseExpr_skipResultType(const ast::Expr * src, Expression * tgt) {
+
+                tgt->location  = src->location;
+                tgt->env       = convertTypeSubstitution(src->env);
+                tgt->extension = src->extension;
+
+                convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
+                return tgt;
+        }
+
         Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
 
-                tgt->location = src->location;
-
                 tgt->result = get<Type>().accept1(src->result);
-                tgt->env    = convertTypeSubstitution(src->env);
-
-                tgt->extension = src->extension;
-                convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
-
-                return tgt;
+                return visitBaseExpr_skipResultType(src, tgt);
         }
 
@@ -628 +631 @@
 
         const ast::Expr * visit( const ast::VirtualCastExpr * node ) override final {
-                auto expr = visitBaseExpr( node,
+                auto expr = visitBaseExpr_skipResultType( node,
                         new VirtualCastExpr(
                                 get<Expression>().accept1(node->arg),
-                                nullptr // cast's "to" type is expr's result type; converted in visitBaseExpr
+                                get<Type>().accept1(node->result)
                         )
                 );
@@ -849 +852 @@
 
         const ast::Expr * visit( const ast::TypeExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new TypeExpr(
+                                get<Type>().accept1(node->type)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::AsmExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new AsmExpr(
+                                get<Expression>().accept1(node->inout),
+                                get<Expression>().accept1(node->constraint),
+                                get<Expression>().accept1(node->operand)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) override final {
-                (void)node;
+                auto rslt = new ImplicitCopyCtorExpr(
+                        get<ApplicationExpr>().accept1(node->callExpr)
+                );
+
+                rslt->tempDecls = get<ObjectDecl>().acceptL(node->tempDecls);
+                rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
+                rslt->dtors = get<Expression>().acceptL(node->dtors);
+
+                auto expr = visitBaseExpr( node, rslt );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::ConstructorExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new ConstructorExpr(
+                                get<Expression>().accept1(node->callExpr)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr_skipResultType( node,
+                        new CompoundLiteralExpr(
+                                get<Type>().accept1(node->result),
+                                get<Initializer>().accept1(node->init)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::RangeExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new RangeExpr(
+                                get<Expression>().accept1(node->low),
+                                get<Expression>().accept1(node->high)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::UntypedTupleExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new UntypedTupleExpr(
+                                get<Expression>().acceptL(node->exprs)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::TupleExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new UntypedTupleExpr(
+                                get<Expression>().acceptL(node->exprs)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::TupleIndexExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new TupleIndexExpr(
+                                get<Expression>().accept1(node->tuple),
+                                node->index
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::TupleAssignExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new TupleAssignExpr(
+                                get<StmtExpr>().accept1(node->stmtExpr)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::StmtExpr * node ) override final {
-                (void)node;
+                auto rslt = new StmtExpr(
+                        get<CompoundStmt>().accept1(node->stmts)
+                );
+
+                rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
+                rslt->dtors       = get<Expression>().acceptL(node->dtors);
+
+                auto expr = visitBaseExpr( node, rslt );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::UniqueExpr * node ) override final {
-                (void)node;
+                auto rslt = new UniqueExpr(
+                        get<Expression>().accept1(node->expr)
+                );
+
+                rslt->object = get<ObjectDecl>  ().accept1(node->object);
+                rslt->var    = get<VariableExpr>().accept1(node->var);
+
+                auto expr = visitBaseExpr( node, rslt );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::UntypedInitExpr * node ) override final {
-                (void)node;
+                std::list<InitAlternative> initAlts;
+                for (auto ia : node->initAlts) {
+                        initAlts.push_back(InitAlternative(
+                                get<Type>       ().accept1(ia.type),
+                                get<Designation>().accept1(ia.designation)
+                        ));
+                }
+                auto expr = visitBaseExpr( node,
+                        new UntypedInitExpr(
+                                get<Expression>().accept1(node->expr),
+                                initAlts
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::InitExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new InitExpr(
+                                get<Expression>().accept1(node->expr),
+                                get<Designation>().accept1(node->designation)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::DeletedExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new DeletedExpr(
+                                get<Expression>().accept1(node->expr),
+                                inCache(node->deleteStmt) ?
+                                        this->node :
+                                        get<BaseSyntaxNode>().accept1(node->deleteStmt)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::DefaultArgExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new DefaultArgExpr(
+                                get<Expression>().accept1(node->expr)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::GenericExpr * node ) override final {
-                (void)node;
+                std::list<GenericExpr::Association> associations;
+                for (auto association : node->associations) {
+                        associations.push_back(GenericExpr::Association(
+                                get<Type>      ().accept1(association.type),
+                                get<Expression>().accept1(association.expr)
+                        ));
+                }
+                auto expr = visitBaseExpr( node,
+                        new GenericExpr(
+                                get<Expression>().accept1(node->control),
+                                associations
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
@@ -1741 +1864 @@
         }
 
-        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
-
-                nw->result = GET_ACCEPT_1(result, Type);
+        ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
+
                 nw->env    = convertTypeSubstitution(old->env);
 
@@ -1750 +1872 @@
 
                 return nw;
+        }
+
+        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
+
+                nw->result = GET_ACCEPT_1(result, Type);
+                return visitBaseExpr_SkipResultType(old, nw);;
         }
 
@@ -1817 +1945 @@
 
         virtual void visit( VirtualCastExpr * old ) override final {
-                this->node = visitBaseExpr( old,
+                this->node = visitBaseExpr_SkipResultType( old,
                         new ast::VirtualCastExpr(
                                 old->location,
                                 GET_ACCEPT_1(arg, Expr),
-                                nullptr // cast's "to" type is expr's result type; converted in visitBaseExpr
+                                GET_ACCEPT_1(result, Type)
                         )
                 );
@@ -2046 +2174 @@
         }
 
-        virtual void visit( TypeExpr * ) override final {
-
-        }
-
-        virtual void visit( AsmExpr * ) override final {
-
-        }
-
-        virtual void visit( ImplicitCopyCtorExpr * ) override final {
-
-        }
-
-        virtual void visit( ConstructorExpr *  ) override final {
-
-        }
-
-        virtual void visit( CompoundLiteralExpr * ) override final {
-
-        }
-
-        virtual void visit( RangeExpr * ) override final {
-
-        }
-
-        virtual void visit( UntypedTupleExpr * ) override final {
-
-        }
-
-        virtual void visit( TupleExpr * ) override final {
-
-        }
-
-        virtual void visit( TupleIndexExpr * ) override final {
-
-        }
-
-        virtual void visit( TupleAssignExpr * ) override final {
-
-        }
-
-        virtual void visit( StmtExpr *  ) override final {
-
-        }
-
-        virtual void visit( UniqueExpr *  ) override final {
-
-        }
-
-        virtual void visit( UntypedInitExpr *  ) override final {
-
-        }
-
-        virtual void visit( InitExpr *  ) override final {
-
-        }
-
-        virtual void visit( DeletedExpr * ) override final {
-
-        }
-
-        virtual void visit( DefaultArgExpr * ) override final {
-
-        }
-
-        virtual void visit( GenericExpr * ) override final {
-
+        virtual void visit( TypeExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::TypeExpr(
+                                old->location,
+                                GET_ACCEPT_1(type, Type)
+                        )
+                );
+        }
+
+        virtual void visit( AsmExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::AsmExpr(
+                                old->location,
+                                GET_ACCEPT_1(inout, Expr),
+                                GET_ACCEPT_1(constraint, Expr),
+                                GET_ACCEPT_1(operand, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( ImplicitCopyCtorExpr * old ) override final {
+                auto rslt = new ast::ImplicitCopyCtorExpr(
+                        old->location,
+                        GET_ACCEPT_1(callExpr, ApplicationExpr)
+                );
+
+                rslt->tempDecls = GET_ACCEPT_V(tempDecls, ObjectDecl);
+                rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
+                rslt->dtors = GET_ACCEPT_V(dtors, Expr);
+
+                this->node = visitBaseExpr( old, rslt );
+        }
+
+        virtual void visit( ConstructorExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::ConstructorExpr(
+                                old->location,
+                                GET_ACCEPT_1(callExpr, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( CompoundLiteralExpr * old ) override final {
+                this->node = visitBaseExpr_SkipResultType( old,
+                        new ast::CompoundLiteralExpr(
+                                old->location,
+                                GET_ACCEPT_1(result, Type),
+                                GET_ACCEPT_1(initializer, Init)
+                        )
+                );
+        }
+
+        virtual void visit( RangeExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::RangeExpr(
+                                old->location,
+                                GET_ACCEPT_1(low, Expr),
+                                GET_ACCEPT_1(high, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( UntypedTupleExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::UntypedTupleExpr(
+                                old->location,
+                                GET_ACCEPT_V(exprs, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( TupleExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::TupleExpr(
+                                old->location,
+                                GET_ACCEPT_V(exprs, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( TupleIndexExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::TupleIndexExpr(
+                                old->location,
+                                GET_ACCEPT_1(tuple, Expr),
+                                old->index
+                        )
+                );
+        }
+
+        virtual void visit( TupleAssignExpr * old ) override final {
+                this->node = visitBaseExpr_SkipResultType( old,
+                        new ast::TupleAssignExpr(
+                                old->location,
+                                GET_ACCEPT_1(result, Type),
+                                GET_ACCEPT_1(stmtExpr, StmtExpr)
+                        )
+                );
+        }
+
+        virtual void visit( StmtExpr * old ) override final {
+                auto rslt = new ast::StmtExpr(
+                        old->location,
+                        GET_ACCEPT_1(statements, CompoundStmt)
+                );
+                rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
+                rslt->dtors       = GET_ACCEPT_V(dtors      , Expr);
+
+                this->node = visitBaseExpr_SkipResultType( old, rslt );
+        }
+
+        virtual void visit( UniqueExpr * old ) override final {
+                auto rslt = new ast::UniqueExpr(
+                        old->location,
+                        GET_ACCEPT_1(expr, Expr)
+                );
+                rslt->object = GET_ACCEPT_1(object, ObjectDecl);
+                rslt->var    = GET_ACCEPT_1(var   , VariableExpr);
+
+                this->node = visitBaseExpr( old, rslt );
+        }
+
+        virtual void visit( UntypedInitExpr * old ) override final {
+                std::vector<ast::InitAlternative> initAlts;
+                for (auto ia : old->initAlts) {
+                        initAlts.push_back(ast::InitAlternative(
+                                getAccept1< ast::Type, Type * >( ia.type ),
+                                getAccept1< ast::Designation, Designation * >( ia.designation )
+                        ));
+                }
+                this->node = visitBaseExpr( old,
+                        new ast::UntypedInitExpr(
+                                old->location,
+                                GET_ACCEPT_1(expr, Expr),
+                                std::move(initAlts)
+                        )
+                );
+        }
+
+        virtual void visit( InitExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::InitExpr(
+                                old->location,
+                                GET_ACCEPT_1(expr, Expr),
+                                GET_ACCEPT_1(designation, Designation)
+                        )
+                );
+        }
+
+        virtual void visit( DeletedExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::DeletedExpr(
+                                old->location,
+                                GET_ACCEPT_1(expr, Expr),
+                                inCache(old->deleteStmt) ?
+                                        this->node :
+                                        GET_ACCEPT_1(deleteStmt, Node)
+                        )
+                );
+        }
+
+        virtual void visit( DefaultArgExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::DefaultArgExpr(
+                                old->location,
+                                GET_ACCEPT_1(expr, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( GenericExpr * old ) override final {
+                std::vector<ast::GenericExpr::Association> associations;
+                for (auto association : old->associations) {
+                        associations.push_back(ast::GenericExpr::Association(
+                                getAccept1< ast::Type, Type * >( association.type ),
+                                getAccept1< ast::Expr, Expression * >( association.expr )
+                        ));
+                }
+                this->node = visitBaseExpr( old,
+                        new ast::GenericExpr(
+                                old->location,
+                                GET_ACCEPT_1(control, Expr),
+                                std::move(associations)
+                        )
+                );
         }
 

src/AST/Expr.cpp

@@ -335 +335 @@
 }
 
+TupleAssignExpr::TupleAssignExpr( 
+        const CodeLocation & loc, const Type * result, const StmtExpr * s )
+: Expr( loc, result ), stmtExpr() {
+        stmtExpr = s;
+}
+
 // --- StmtExpr
 

src/AST/Expr.hpp

@@ -30 +30 @@
 #define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
+class ConverterOldToNew;
+
 namespace ast {
 
@@ -528 +530 @@
         std::vector<ptr<ObjectDecl>> tempDecls;
         std::vector<ptr<ObjectDecl>> returnDecls;
-        std::vector<ptr<ObjectDecl>> dtors;
+        std::vector<ptr<Expr>> dtors;
 
         ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
@@ -635 +637 @@
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+
+        friend class ::ConverterOldToNew;
+
 private:
         TupleAssignExpr * clone() const override { return new TupleAssignExpr{ *this }; }
+    TupleAssignExpr( const CodeLocation & loc, const Type * result, const StmtExpr * s );
+
         MUTATE_FRIEND
 };

src/AST/Node.cpp

@@ -26 +26 @@
 #include "Type.hpp"
 #include "TypeSubstitution.hpp"
+
+#include "Print.hpp"
 
 template< typename node_t, enum ast::Node::ref_type ref_t >
@@ -47 +49 @@
 
 std::ostream & ast::operator<< ( std::ostream & out, const ast::Node * node ) {
-        (void)node;
-        #warning unimplemented
-        assertf(false, "Unimplemented");
+        print(out, node);
         return out;
 }

src/AST/module.mk

@@ -24 +24 @@
         AST/LinkageSpec.cpp \
         AST/Node.cpp \
+        AST/Print.cpp \
         AST/Stmt.cpp \
         AST/Type.cpp \

src/Makefile.in

@@ -169 +169 @@
         AST/Expr.$(OBJEXT) AST/Init.$(OBJEXT) \
         AST/LinkageSpec.$(OBJEXT) AST/Node.$(OBJEXT) \
-        AST/Stmt.$(OBJEXT) AST/Type.$(OBJEXT) \
+        AST/Print.$(OBJEXT) AST/Stmt.$(OBJEXT) AST/Type.$(OBJEXT) \
         AST/TypeSubstitution.$(OBJEXT)
 am__objects_2 = CodeGen/CodeGenerator.$(OBJEXT) \
@@ -577 +577 @@
         AST/LinkageSpec.cpp \
         AST/Node.cpp \
+        AST/Print.cpp \
         AST/Stmt.cpp \
         AST/Type.cpp \
@@ -741 +742 @@
         AST/$(DEPDIR)/$(am__dirstamp)
 AST/Node.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
+AST/Print.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
 AST/Stmt.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
 AST/Type.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
@@ -1172 +1174 @@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/LinkageSpec.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Node.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Print.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Stmt.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Type.Po@am__quote@

src/SynTree/Expression.h

@@ -741 +741 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const;
+
+        friend class ConverterNewToOld;
+  private:
+    TupleAssignExpr( StmtExpr * stmts );
 };
 

src/SynTree/TupleExpr.cc

@@ -105 +105 @@
 }
 
+TupleAssignExpr::TupleAssignExpr( 
+        StmtExpr * s )
+: Expression(), stmtExpr(s) {
+}
+
+
 TupleAssignExpr::~TupleAssignExpr() {
         delete stmtExpr;