Changes in src/InitTweak/InitTweak.cc [13d326ec:720f2fe2]

File:

• src/InitTweak/InitTweak.cc (modified) (10 diffs)

src/InitTweak/InitTweak.cc

@@ -27 +27 @@
 #include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
-#include "CodeGen/OperatorTable.h" // for isConstructor, isDestructor, isCto...
 #include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
@@ -771 +770 @@
                         std::list< Expression * > callExprs;
                         collectCtorDtorCalls( stmt, callExprs );
+                        // if ( callExprs.empty() ) return false; // xxx - do I still need this check?
                         return std::all_of( callExprs.begin(), callExprs.end(), pred);
                 }
@@ -901 +901 @@
                         } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
                                 return varExpr->get_var()->get_name();
-                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
+                        }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
                                 return funcName( castExpr->get_arg() );
                         } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( func ) ) {
@@ -923 +923 @@
                         } else if ( const ast::VariableExpr * varExpr = dynamic_cast< const ast::VariableExpr * >( func ) ) {
                                 return varExpr->var->name;
-                        } else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( func ) ) {
+                        }       else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( func ) ) {
                                 return funcName( castExpr->arg );
                         } else if ( const ast::MemberExpr * memberExpr = dynamic_cast< const ast::MemberExpr * >( func ) ) {
@@ -991 +991 @@
 
         Type * isPointerType( Type * type ) {
-                return getPointerBase( type ) ? type : nullptr;
+                if ( getPointerBase( type ) ) return type;
+                else return nullptr;
         }
 
@@ -1013 +1014 @@
                                 src = new AddressExpr( src );
                         }
+                        // src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
                 }
                 return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
@@ -1165 +1167 @@
         }
 
+        bool isConstructor( const std::string & str ) { return str == "?{}"; }
+        bool isDestructor( const std::string & str ) { return str == "^?{}"; }
+        bool isAssignment( const std::string & str ) { return str == "?=?"; }
+        bool isCtorDtor( const std::string & str ) { return isConstructor( str ) || isDestructor( str ); }
+        bool isCtorDtorAssign( const std::string & str ) { return isCtorDtor( str ) || isAssignment( str ); }
+
         const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname ) {
                 const FunctionDecl * function = dynamic_cast< const FunctionDecl * >( decl );
@@ -1184 +1192 @@
 
 bool isAssignment( const ast::FunctionDecl * decl ) {
-        return CodeGen::isAssignment( decl->name ) && isCopyFunction( decl );
+        return isAssignment( decl->name ) && isCopyFunction( decl );
 }
 
 bool isDestructor( const ast::FunctionDecl * decl ) {
-        return CodeGen::isDestructor( decl->name );
+        return isDestructor( decl->name );
 }
 
 bool isDefaultConstructor( const ast::FunctionDecl * decl ) {
-        return CodeGen::isConstructor( decl->name ) && 1 == decl->params.size();
+        return isConstructor( decl->name ) && 1 == decl->params.size();
 }
 
 bool isCopyConstructor( const ast::FunctionDecl * decl ) {
-        return CodeGen::isConstructor( decl->name ) && 2 == decl->params.size();
+        return isConstructor( decl->name ) && 2 == decl->params.size();
 }
 
@@ -1214 +1222 @@
         }
         const FunctionDecl * isDestructor( const Declaration * decl ) {
-                if ( CodeGen::isDestructor( decl->name ) ) {
+                if ( isDestructor( decl->name ) ) {
                         return dynamic_cast< const FunctionDecl * >( decl );
                 }
@@ -1220 +1228 @@
         }
         const FunctionDecl * isDefaultConstructor( const Declaration * decl ) {
-                if ( CodeGen::isConstructor( decl->name ) ) {
+                if ( isConstructor( decl->name ) ) {
                         if ( const FunctionDecl * func = dynamic_cast< const FunctionDecl * >( decl ) ) {
                                 if ( func->type->parameters.size() == 1 ) {