Changes in src/SymTab/Autogen.h [1a5ad8c:a4477db]

File:

• src/SymTab/Autogen.h (modified) (10 diffs)

src/SymTab/Autogen.h

@@ -19 +19 @@
 #include <string>                 // for string
 
-#include "CodeGen/OperatorTable.h"
 #include "Common/UniqueName.h"    // for UniqueName
 #include "InitTweak/InitTweak.h"  // for InitExpander
@@ -52 +51 @@
 
         // generate the type of a copy constructor for paramType
-        FunctionType * genCopyType( Type * paramType );
+        FunctionType * genDefaultType( Type * paramType );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
@@ -61 +60 @@
         /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
         template< typename OutputIterator >
-        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, bool addCast = false ) {
-                bool isReferenceCtorDtor = false;
-                if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
-                        // reference constructors are essentially application of the rebind operator.
-                        // apply & to both arguments, do not need a cast
-                        fname = "?=?";
-                        dstParam = new AddressExpr( dstParam );
-                        addCast = false;
-                        isReferenceCtorDtor = true;
-                }
-
+        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
                 // want to be able to generate assignment, ctor, and dtor generically,
                 // so fname is either ?=?, ?{}, or ^?{}
-                UntypedExpr * fExpr = new UntypedExpr( new NameExpr( fname ) );
+                UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
 
                 if ( addCast ) {
@@ -89 +78 @@
                         dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );
                 }
-                fExpr->args.push_back( dstParam );
+                fExpr->get_args().push_back( dstParam );
 
                 Statement * listInit = srcParam.buildListInit( fExpr );
 
-                // fetch next set of arguments
-                ++srcParam;
-
-                // return if adding reference fails - will happen on default constructor and destructor
-                if ( isReferenceCtorDtor && ! srcParam.addReference() ) {
-                        delete fExpr;
-                        return listInit;
-                }
-
-                std::list< Expression * > args = *srcParam;
-                fExpr->args.splice( fExpr->args.end(), args );
+                std::list< Expression * > args = *++srcParam;
+                fExpr->get_args().splice( fExpr->get_args().end(), args );
 
                 *out++ = new ExprStmt( noLabels, fExpr );
@@ -125 +105 @@
                         // generate: for ( int i = 0; i < N; ++i )
                         begin = new ConstantExpr( Constant::from_int( 0 ) );
-                        end = array->dimension->clone();
+                        end = array->get_dimension()->clone();
                         cmp = new NameExpr( "?<?" );
                         update = new NameExpr( "++?" );
@@ -131 +111 @@
                         // generate: for ( int i = N-1; i >= 0; --i )
                         begin = new UntypedExpr( new NameExpr( "?-?" ) );
-                        ((UntypedExpr*)begin)->args.push_back( array->dimension->clone() );
-                        ((UntypedExpr*)begin)->args.push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
+                        ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
+                        ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
                         end = new ConstantExpr( Constant::from_int( 0 ) );
                         cmp = new NameExpr( "?>=?" );
@@ -141 +121 @@
 
                 UntypedExpr *cond = new UntypedExpr( cmp );
-                cond->args.push_back( new VariableExpr( index ) );
-                cond->args.push_back( end );
+                cond->get_args().push_back( new VariableExpr( index ) );
+                cond->get_args().push_back( end );
 
                 UntypedExpr *inc = new UntypedExpr( update );
-                inc->args.push_back( new VariableExpr( index ) );
+                inc->get_args().push_back( new VariableExpr( index ) );
 
                 UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
-                dstIndex->args.push_back( dstParam );
-                dstIndex->args.push_back( new VariableExpr( index ) );
+                dstIndex->get_args().push_back( dstParam );
+                dstIndex->get_args().push_back( new VariableExpr( index ) );
                 dstParam = dstIndex;
 
                 // srcParam must keep track of the array indices to build the
                 // source parameter and/or array list initializer
-                srcParam.addArrayIndex( new VariableExpr( index ), array->dimension->clone() );
+                srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
 
                 // for stmt's body, eventually containing call
                 CompoundStmt * body = new CompoundStmt( noLabels );
-                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->kids ), array->base, addCast, forward );
+                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
 
                 // block containing for stmt and index variable
                 std::list<Statement *> initList;
                 CompoundStmt * block = new CompoundStmt( noLabels );
-                block->push_back( new DeclStmt( noLabels, index ) );
+                block->get_kids().push_back( new DeclStmt( noLabels, index ) );
                 if ( listInit ) block->get_kids().push_back( listInit );
-                block->push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+                block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
 
                 *out++ = block;
@@ -171 +151 @@
 
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
+        Statement * genCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
@@ -185 +165 @@
         /// ImplicitCtorDtorStmt node.
         template< typename OutputIterator >
-        void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
+        void genImplicitCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
                 ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
                 assert( obj );
@@ -193 +173 @@
                 bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) );
                 std::list< Statement * > stmts;
-                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->type, addCast, forward );
+                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
 
                 // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call