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

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
@@ -40 +41 @@
         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 >
@@ -47 +61 @@
         /// 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, 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 ) );
-
-        // 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 );
-
-        Statement * listInit = srcParam.buildListInit( fExpr );
-
-        std::list< Expression * > args = *++srcParam;
-        fExpr->get_args().splice( fExpr->get_args().end(), args );
-
-        *out++ = new ExprStmt( noLabels, fExpr );
-
-        srcParam.clearArrayIndices();
-
-        return listInit;
+        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;
+                }
+
+                // want to be able to generate assignment, ctor, and dtor generically,
+                // so fname is either ?=?, ?{}, or ^?{}
+                UntypedExpr * fExpr = new UntypedExpr( new NameExpr( fname ) );
+
+                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 );
+
+                // 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 );
+
+                *out++ = new ExprStmt( noLabels, fExpr );
+
+                srcParam.clearArrayIndices();
+
+                return listInit;
         }
 
@@ -94 +125 @@
                         // generate: for ( int i = 0; i < N; ++i )
                         begin = new ConstantExpr( Constant::from_int( 0 ) );
-                        end = array->get_dimension()->clone();
+                        end = array->dimension->clone();
                         cmp = new NameExpr( "?<?" );
                         update = new NameExpr( "++?" );
@@ -100 +131 @@
                         // generate: for ( int i = N-1; i >= 0; --i )
                         begin = new UntypedExpr( new NameExpr( "?-?" ) );
-                        ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
-                        ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
+                        ((UntypedExpr*)begin)->args.push_back( array->dimension->clone() );
+                        ((UntypedExpr*)begin)->args.push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
                         end = new ConstantExpr( Constant::from_int( 0 ) );
                         cmp = new NameExpr( "?>=?" );
@@ -110 +141 @@
 
                 UntypedExpr *cond = new UntypedExpr( cmp );
-                cond->get_args().push_back( new VariableExpr( index ) );
-                cond->get_args().push_back( end );
+                cond->args.push_back( new VariableExpr( index ) );
+                cond->args.push_back( end );
 
                 UntypedExpr *inc = new UntypedExpr( update );
-                inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+                inc->args.push_back( new VariableExpr( index ) );
 
                 UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
-                dstIndex->get_args().push_back( dstParam );
-                dstIndex->get_args().push_back( new VariableExpr( index ) );
+                dstIndex->args.push_back( dstParam );
+                dstIndex->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->get_dimension()->clone() );
+                srcParam.addArrayIndex( new VariableExpr( index ), array->dimension->clone() );
 
                 // for stmt's body, eventually containing call
                 CompoundStmt * body = new CompoundStmt( noLabels );
-                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
+                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->kids ), array->base, addCast, forward );
 
                 // block containing for stmt and index variable
                 std::list<Statement *> initList;
                 CompoundStmt * block = new CompoundStmt( noLabels );
-                block->get_kids().push_back( new DeclStmt( noLabels, index ) );
+                block->push_back( new DeclStmt( noLabels, index ) );
                 if ( listInit ) block->get_kids().push_back( listInit );
-                block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+                block->push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
 
                 *out++ = block;
@@ -140 +171 @@
 
         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 );
@@ -154 +185 @@
         /// 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 );
@@ -162 +193 @@
                 bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) );
                 std::list< Statement * > stmts;
-                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
+                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->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