Changeset 4d59ff9

Timestamp:

Sep 13, 2018, 2:30:53 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

a4a000d

Parents:

40cd873

Message:

Handle initializers and returns in RPDump

File:

• src/CodeTools/ResolvProtoDump.cc (modified) (7 diffs)

src/CodeTools/ResolvProtoDump.cc

@@ -27 +27 @@
 
 #include "Common/PassVisitor.h"
+#include "Common/utility.h"
 #include "CodeGen/OperatorTable.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
@@ -41 +43 @@
                 std::vector<ProtoDump> subs;     ///< Sub-scopes
                 const ProtoDump* parent;         ///< Outer lexical scope
+                std::unique_ptr<Type> rtnType;   ///< Return type for this scope
 
         public:
                 /// Default constructor for root ProtoDump
-                ProtoDump() : decls(), exprs(), subs(), parent(nullptr) {}
+                ProtoDump() : decls(), exprs(), subs(), parent(nullptr), rtnType(nullptr) {}
 
                 /// Child constructor
-                ProtoDump(const ProtoDump* p) : decls(), exprs(), subs(), parent(p) {}
+                ProtoDump(const ProtoDump* p, Type* r) : decls(), exprs(), subs(), parent(p), rtnType(r) {}
+
+                // Fix copy issues
+                ProtoDump( const ProtoDump& o ) 
+                        : decls(o.decls), exprs(o.exprs), subs(o.subs), parent(o.parent), 
+                          rtnType(maybeClone(o.rtnType.get())) {}
+                ProtoDump( ProtoDump&& ) = default;
+
+                ProtoDump& operator= ( const ProtoDump& o ) {
+                        if ( this == &o ) return *this;
+
+                        decls = o.decls;
+                        exprs = o.exprs;
+                        subs = o.subs;
+                        parent = o.parent;
+                        rtnType.reset( maybeClone(o.rtnType.get()) );
+                        
+                        return *this;
+                }
+                ProtoDump& operator= ( ProtoDump&& ) = default;
 
         private:
@@ -474 +496 @@
                 };
 
+                void build( Initializer* init, std::stringstream& ss ) {
+                        if ( SingleInit* si = dynamic_cast<SingleInit*>(init) ) {
+                                PassVisitor<ExprPrinter> exprPrinter{ ss };
+                                si->value->accept( exprPrinter );
+                                ss << ' ';
+                        } else if ( ListInit* li = dynamic_cast<ListInit*>(init) ) {
+                                for ( Initializer* it : li->initializers ) {
+                                        build( it, ss );
+                                        ss << ' ';
+                                }
+                        }
+                }
+
+                /// Adds an object initializer to the list of expressions
+                void build( const std::string& name, Initializer* init, std::stringstream& ss ) {
+                        ss << "$constructor( ";
+                        rp_name( name, ss );
+                        ss << "() ";
+                        build( init, ss );
+                        ss << ')';
+                }
+
+                /// Adds a return expression to the list of expressions
+                void build( Type* rtnType, Expression* expr, std::stringstream& ss ) {
+                        ss << "$constructor( ";
+                        PassVisitor<TypePrinter> tyPrinter{ ss };
+                        rtnType->accept( tyPrinter );
+                        ss << ' ';
+                        PassVisitor<ExprPrinter> exprPrinter{ ss };
+                        expr->accept( exprPrinter );
+                        ss << " )";
+                }
+
                 /// Adds all named declarations in a list to the local scope
                 void addAll( const std::list<DeclarationWithType*>& decls ) {
@@ -507 +562 @@
                         build( obj->name, obj->type, ss );
                         addDecl( ss.str() );
+
+                        // add initializer as expression if applicable
+                        if ( obj->init ) {
+                                std::stringstream ss;
+                                build( obj->name, obj->init, ss );
+                                addExpr( ss.str() );
+                        }
                 }
 
@@ -517 +579 @@
                         // add body if available
                         if ( decl->statements ) {
-                                PassVisitor<ProtoDump> body{ this };
+                                std::list<Type*> rtns = from_decls( decl->type->returnVals );
+                                Type* rtn = nullptr;
+                                if ( rtns.size() == 1 ) {
+                                        if ( ! dynamic_cast<VoidType*>(rtns.front()) ) rtn = rtns.front()->clone();
+                                } else if ( rtns.size() > 1 ) {
+                                        rtn = new TupleType{ Type::Qualifiers{}, rtns };
+                                }
+                                PassVisitor<ProtoDump> body{ this, rtn };
                                 
                                 // add named parameters and returns to local scope
@@ -554 +623 @@
                 }
 
+                void previsit( ReturnStmt* stmt ) {
+                        // do nothing for void-returning functions or statements returning nothing
+                        if ( ! rtnType || ! stmt->expr ) return;
+
+                        // otherwise construct the return type from the expression
+                        std::stringstream ss;
+                        build( rtnType.get(), stmt->expr, ss );
+                        addExpr( ss.str() );
+                        visit_children = false;
+                }
+
                 void previsit( Expression* expr ) {
                         std::stringstream ss;
@@ -571 +651 @@
                         }
                         // print divider
-                        std::cout << tab << "%%" << std::endl;
+                        std::cout << '\n' << tab << "%%\n" << std::endl;
                         // print top-level expressions
                         for ( const std::string& e : exprs ) {