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

File:

• src/SymTab/Autogen.h (modified) (9 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
@@ -41 +40 @@
         extern Type * SizeType;
 
-        /// intrinsic dereference operator for unqualified types - set when *? function is seen in FindSpecialDeclarations.
-        /// Useful for creating dereference ApplicationExprs without a full resolver pass.
-        extern FunctionDecl * dereferenceOperator;
-
-        // generate the type of an assignment function for paramType
-        FunctionType * genAssignType( Type * paramType );
-
-        // generate the type of a default constructor or destructor for paramType
-        FunctionType * genDefaultType( Type * paramType );
-
-        // generate the type of a copy constructor for paramType
-        FunctionType * genCopyType( 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.
         template< typename OutputIterator >
@@ -61 +47 @@
         /// 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 ) );
 
-                // want to be able to generate assignment, ctor, and dtor generically,
-                // so fname is either ?=?, ?{}, or ^?{}
-                UntypedExpr * fExpr = new UntypedExpr( new NameExpr( fname ) );
+        // do something special for unnamed members
+        dstParam = new AddressExpr( dstParam );
+        if ( addCast ) {
+                // cast to T* with qualifiers removed, so that qualified objects can be constructed
+                // and destructed with the same functions as non-qualified objects.
+                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
+                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
+                // remove lvalue as a qualifier, this can change to
+                //   type->get_qualifiers() = Type::Qualifiers();
+                assert( type );
+                Type * castType = type->clone();
+                castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                castType->set_lvalue( true ); // xxx - might not need this
+                dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
+        }
+        fExpr->get_args().push_back( dstParam );
 
-                if ( addCast ) {
-                        // cast to T& with qualifiers removed, so that qualified objects can be constructed
-                        // and destructed with the same functions as non-qualified objects.
-                        // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
-                        // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
-                        // remove lvalue as a qualifier, this can change to
-                        //   type->get_qualifiers() = Type::Qualifiers();
-                        assert( type );
-                        Type * castType = type->clone();
-                        castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
-                        // castType->set_lvalue( true ); // xxx - might not need this
-                        dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );
-                }
-                fExpr->args.push_back( dstParam );
+        Statement * listInit = srcParam.buildListInit( fExpr );
 
-                Statement * listInit = srcParam.buildListInit( fExpr );
+        std::list< Expression * > args = *++srcParam;
+        fExpr->get_args().splice( fExpr->get_args().end(), args );
 
-                // fetch next set of arguments
-                ++srcParam;
+        *out++ = new ExprStmt( noLabels, fExpr );
 
-                // return if adding reference fails - will happen on default constructor and destructor
-                if ( isReferenceCtorDtor && ! srcParam.addReference() ) {
-                        delete fExpr;
-                        return listInit;
-                }
+        srcParam.clearArrayIndices();
 
-                std::list< Expression * > args = *srcParam;
-                fExpr->args.splice( fExpr->args.end(), args );
-
-                *out++ = new ExprStmt( noLabels, fExpr );
-
-                srcParam.clearArrayIndices();
-
-                return listInit;
+        return listInit;
         }
 
@@ -125 +94 @@
                         // 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 +100 @@
                         // 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 +110 @@
 
                 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 AddressExpr( 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 +140 @@
 
         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 +154 @@
         /// 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 +162 @@
                 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