Changes in src/SymTab/Autogen.h [b4f8808:ba3706f]

File:

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

src/SymTab/Autogen.h

@@ -17 +17 @@
 
 #include <cassert>                // for assert
-#include <iterator>               // for back_inserter
 #include <string>                 // for string
 
-#include "AST/Decl.hpp"
-#include "AST/Expr.hpp"
-#include "AST/Init.hpp"
-#include "AST/Node.hpp"
-#include "AST/Stmt.hpp"
-#include "AST/Type.hpp"
 #include "CodeGen/OperatorTable.h"
 #include "Common/UniqueName.h"    // for UniqueName
-#include "Common/utility.h"       // for splice
 #include "InitTweak/InitTweak.h"  // for InitExpander
 #include "SynTree/Constant.h"     // for Constant
@@ -44 +36 @@
         /// returns true if obj's name is the empty string and it has a bitfield width
         bool isUnnamedBitfield( ObjectDecl * obj );
-        bool isUnnamedBitfield( const ast::ObjectDecl * obj );
-
-        /// generate the type of an assignment function for paramType.
-        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
-        FunctionType * genAssignType( Type * paramType, bool maybePolymorphic = true );
-
-        /// generate the type of a default constructor or destructor for paramType.
-        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
-        FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
-
-        /// generate the type of a copy constructor for paramType.
-        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
-        FunctionType * genCopyType( Type * paramType, bool maybePolymorphic = true );
-
-        /// Enum for loop direction
-        enum LoopDirection { LoopBackward, LoopForward };
+
+        /// size_t type - set when size_t typedef is seen. Useful in a few places,
+        /// such as in determining array dimension type
+        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 >
-        Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
-
-        template< typename OutIter >
-        ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, OutIter && out, 
-                const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
         /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
         template< typename OutputIterator >
-        Statement * genScalarCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
+        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
                 bool isReferenceCtorDtor = false;
                 if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
@@ -97 +84 @@
                         //   type->get_qualifiers() = Type::Qualifiers();
                         Type * castType = addCast->clone();
-                        castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                        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 ) );
@@ -124 +111 @@
         }
 
-        /// inserts into out a generated call expression to function fname with arguments dstParam and 
-        /// srcParam. Should only be called with non-array types.
-        /// optionally returns a statement which must be inserted prior to the containing loop, if 
-        /// there is one
-        template< typename OutIter >
-        ast::ptr< ast::Stmt > genScalarCall( 
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type, 
-                const ast::Type * addCast = nullptr
-        ) {
-                bool isReferenceCtorDtor = false;
-                if ( dynamic_cast< const ast::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 ast::AddressExpr{ dstParam };
-                        addCast = nullptr;
-                        isReferenceCtorDtor = true;
-                }
-
-                // want to be able to generate assignment, ctor, and dtor generically, so fname is one of
-                // "?=?", "?{}", or "^?{}"
-                ast::UntypedExpr * fExpr = new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, 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.
-                        // xxx -- old code actually removed lvalue too...
-                        ast::ptr< ast::Type > guard = addCast;  // prevent castType from mutating addCast
-                        ast::ptr< ast::Type > castType = addCast;
-                        ast::remove_qualifiers( 
-                                castType, 
-                                ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic );
-                        dstParam = new ast::CastExpr{ dstParam, new ast::ReferenceType{ castType } };
-                }
-                fExpr->args.emplace_back( dstParam );
-
-                const ast::Stmt * listInit = srcParam.buildListInit( fExpr );
-
-                // fetch next set of arguments
-                ++srcParam;
-
-                // return if adding reference fails -- will happen on default ctor and dtor
-                if ( isReferenceCtorDtor && ! srcParam.addReference() ) return listInit;
-
-                std::vector< ast::ptr< ast::Expr > > args = *srcParam;
-                splice( fExpr->args, args );
-
-                *out++ = new ast::ExprStmt{ loc, fExpr };
-
-                srcParam.clearArrayIndices();
-                
-                return listInit;
-        }
-
         /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
         /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
         template< typename OutputIterator >
-        void genArrayCall( InitTweak::InitExpander_old & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
+        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
                 static UniqueName indexName( "_index" );
 
@@ -245 +175 @@
         }
 
-        /// Store in out a loop which calls fname on each element of the array with srcParam and 
-        /// dstParam as arguments. If forward is true, loop goes from 0 to N-1, else N-1 to 0
-        template< typename OutIter >
-        void genArrayCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, OutIter && out, 
-                const ast::ArrayType * array, const ast::Type * addCast = nullptr, 
-                LoopDirection forward = LoopForward 
-        ) {
-                static UniqueName indexName( "_index" );
-
-                // for a flexible array member nothing is done -- user must define own assignment
-                if ( ! array->dimension ) return;
-
-                if ( addCast ) {
-                        // peel off array layer from cast
-                        addCast = strict_dynamic_cast< const ast::ArrayType * >( addCast )->base;
-                }
-
-                ast::ptr< ast::Expr > begin, end, cmp, update;
-
-                if ( forward ) {
-                        // generate: for ( int i = 0; i < N; ++i )
-                        begin = ast::ConstantExpr::from_int( loc, 0 );
-                        end = array->dimension;
-                        cmp = new ast::NameExpr{ loc, "?<?" };
-                        update = new ast::NameExpr{ loc, "++?" };
-                } else {
-                        // generate: for ( int i = N-1; i >= 0; --i )
-                        begin = new ast::UntypedExpr{ 
-                                loc, new ast::NameExpr{ loc, "?-?" }, 
-                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } };
-                        end = ast::ConstantExpr::from_int( loc, 0 );
-                        cmp = new ast::NameExpr{ loc, "?>=?" };
-                        update = new ast::NameExpr{ loc, "--?" };
-                }
-
-                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{ 
-                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt }, 
-                        new ast::SingleInit{ loc, begin } };
-                
-                ast::ptr< ast::Expr > cond = new ast::UntypedExpr{
-                        loc, cmp, { new ast::VariableExpr{ loc, index }, end } };
-                
-                ast::ptr< ast::Expr > inc = new ast::UntypedExpr{
-                        loc, update, { new ast::VariableExpr{ loc, index } } };
-                
-                ast::ptr< ast::Expr > dstIndex = new ast::UntypedExpr{
-                        loc, new ast::NameExpr{ loc, "?[?]" }, 
-                        { dstParam, new ast::VariableExpr{ loc, index } } };
-                
-                // srcParam must keep track of the array indices to build the source parameter and/or 
-                // array list initializer
-                srcParam.addArrayIndex( new ast::VariableExpr{ loc, index }, array->dimension );
-
-                // for stmt's body, eventually containing call
-                ast::CompoundStmt * body = new ast::CompoundStmt{ loc };
-                ast::ptr< ast::Stmt > listInit = genCall( 
-                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast, 
-                        forward );
-                
-                // block containing the stmt and index variable
-                ast::CompoundStmt * block = new ast::CompoundStmt{ loc };
-                block->push_back( new ast::DeclStmt{ loc, index } );
-                if ( listInit ) { block->push_back( listInit ); }
-                block->push_back( new ast::ForStmt{ loc, {}, cond, inc, body } );
-
-                *out++ = block;
-        }
-
-        template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
+        template< typename OutputIterator >
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
@@ -325 +185 @@
         }
 
-        template< typename OutIter >
-        ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, OutIter && out, 
-                const ast::Type * type, const ast::Type * addCast, LoopDirection forward
-        ) {
-                if ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
-                        genArrayCall( 
-                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast, 
-                                forward );
-                        return {};
-                } else {
-                        return genScalarCall( 
-                                srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
-                }
-        }
-
         /// inserts into out a generated call expression to function fname with arguments dstParam
         /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
@@ -347 +190 @@
         /// ImplicitCtorDtorStmt node.
         template< typename OutputIterator >
-        void genImplicitCall( InitTweak::InitExpander_old & 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 );
@@ -375 +218 @@
                 }
         }
-
-        static inline ast::ptr< ast::Stmt > genImplicitCall( 
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj, 
-                LoopDirection forward = LoopForward 
-        ) {
-                // unnamed bit fields are not copied as they cannot be accessed
-                if ( isUnnamedBitfield( obj ) ) return {};
-
-                ast::ptr< ast::Type > addCast = nullptr;
-                if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
-                        assert( dstParam->result );
-                        addCast = dstParam->result;
-                }
-
-                std::vector< ast::ptr< ast::Stmt > > stmts;
-                genCall( 
-                        srcParam, dstParam, loc, fname, back_inserter( stmts ), obj->type, addCast, forward );
-
-                if ( stmts.empty() ) {
-                        return {};
-                } else if ( stmts.size() == 1 ) {
-                        const ast::Stmt * callStmt = stmts.front();
-                        if ( addCast ) {
-                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are 
-                                // aware they were generated.
-                                callStmt = new ast::ImplicitCtorDtorStmt{ callStmt->location, callStmt };
-                        }
-                        return callStmt;
-                } else {
-                        assert( false );
-                        return {};
-                }
-        }
 } // namespace SymTab