Changeset 933f32f for src/InitTweak

Timestamp:

May 24, 2019, 10:19:41 AM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

d908563

Parents:

6a9d4b4 (diff), 292642a (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' into cleanup-dtors

Location:

src/InitTweak

Files:

• FixInit.cc (modified) (2 diffs)
• InitTweak.cc (modified) (5 diffs)
• InitTweak.h (modified) (2 diffs)
• module.mk (modified) (1 diff)

src/InitTweak/FixInit.cc

@@ -10 +10 @@
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 21 17:35:05 2017
-// Update Count     : 74
+// Last Modified On : Wed Feb 13 18:15:56 2019
+// Update Count     : 76
 //
 #include "FixInit.h"
@@ -72 +72 @@
                 };
 
-                struct InsertImplicitCalls : public WithTypeSubstitution {
+                struct InsertImplicitCalls : public WithConstTypeSubstitution {
                         /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
                         /// function calls need their parameters to be copy constructed

src/InitTweak/InitTweak.cc

@@ -5 +5 @@
 #include <memory>                  // for __shared_ptr
 
+#include "AST/Expr.hpp"
+#include "AST/Stmt.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
@@ -26 +29 @@
 #include "Tuples/Tuples.h"         // for Tuples::isTtype
 
-class UntypedValofExpr;
-
 namespace InitTweak {
         namespace {
@@ -432 +433 @@
                         assert( false );
                 }
+
+                // template<typename CallExpr>
+                // const ast::Expr * callArg( const CallExpr * call, unsigned int pos ) {
+                //      if( pos >= call->args.size() ) {
+                //              assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.",
+                //                      pos, toString( call ).c_str() );
+                //      }
+                //      for ( const ast::Expr * arg : call->args ) {
+                //              if ( pos == 0 ) return arg;
+                //              --pos;
+                //      }
+                //      assert( false );
+                // }
         }
 
@@ -451 +465 @@
                         assertf( false, "Unexpected expression type passed to getCallArg: %s", toString( callExpr ).c_str() );
                 }
+        }
+        const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos ) {
+                (void)call;
+                (void)pos;
+                #warning unimplemented; needs to build AST/Expr.cpp
+                assertf(false, "unimplemented; needs to build AST/Expr.cpp");
+                // if ( auto app = dynamic_cast< const ast::ApplicationExpr * >( call ) ) {
+                //      return callArg( app, pos );
+                // } else if ( auto untyped = dynamic_cast< const ast::UntypedExpr * >( call ) ) {
+                //      return callArg( untyped, pos );
+                // } else if ( auto tupleAssn = dynamic_cast< const ast::TupleAssignExpr * >( call ) ) {
+                //      const std::list<ast::ptr<ast::Stmt>>& stmts = tupleAssn->stmtExpr->stmts->kids;
+                //      assertf( ! stmts.empty(), "TupleAssignExpr missing statements." );
+                //      const ExprStmt * stmt = strict_dynamic_cast< const ast::ExprStmt * >( stmts.back() );
+                //      const TupleExpr * tuple = strict_dynamic_cast< const ast::TupleExpr * >( stmt->expr );
+                //      assertf( ! tuple->exprs.empty(), "TupleAssignExpr has empty tuple expr.");
+                //      return getCallArg( tuple->exprs.front(), pos );
+                // } else if ( auto ctor = dynamic_cast< const ast::ImplicitCopyCtorExpr * >( call ) ) {
+                //      return getCallArg( ctor->callExpr, pos );
+                // } else {
+                //      assertf( false, "Unexpected expression type passed to getCallArg: %s",
+                //              toString( call ).c_str() );
+                // }
         }
 
@@ -513 +550 @@
                 }
         }
+        const ast::Type* getPointerBase( const ast::Type* t ) {
+                (void)t;
+                #warning needs to build Type.cpp before inclusion
+                assertf(false, "needs to build Type.cpp before inclusion");
+                // if ( const auto * p = dynamic_cast< const ast::PointerType * >( t ) ) {
+                //      return p->base;
+                // } else if ( const auto * a = dynamic_cast< const ast::ArrayType * >( t ) ) {
+                //      return a->base;
+                // } else if ( const auto * r = dynamic_cast< const ast::ReferenceType * >( t ) ) {
+                //      return r->base;
+                // } else return nullptr;
+        }
 
         Type * isPointerType( Type * type ) {

src/InitTweak/InitTweak.h

@@ -20 +20 @@
 #include <string>             // for string, allocator
 
+#include "AST/Fwd.hpp"        // for AST nodes
 #include "SynTree/SynTree.h"  // for Visitor Nodes
 
@@ -80 +81 @@
         /// returns the argument to a call expression in position N indexed from 0
         Expression *& getCallArg( Expression * callExpr, unsigned int pos );
+        const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos );
 
         /// returns the base type of a PointerType or ArrayType, else returns NULL
         Type * getPointerBase( Type * );
+        const ast::Type* getPointerBase( const ast::Type* );
 
         /// returns the argument if it is a PointerType or ArrayType, else returns NULL

src/InitTweak/module.mk

@@ -20 +20 @@
         InitTweak/InitTweak.cc
 
+SRCDEMANGLE += InitTweak/GenInit.cc \
+        InitTweak/InitTweak.cc
+