Changes in src/SymTab/Autogen.h [d56e5bc:6b0b624]

File:

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

src/SymTab/Autogen.h

@@ -10 +10 @@
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 21 17:25:26 2017
-// Update Count     : 14
+// Last Modified On : Sat Jul 22 09:50:25 2017
+// Update Count     : 15
 //
 
-#ifndef AUTOGEN_H
-#define AUTOGEN_H
+#pragma once
 
 #include <string>
@@ -25 +24 @@
 
 namespace SymTab {
-    /// Generates assignment operators, constructors, and destructor for aggregate types as required
-    void autogenerateRoutines( std::list< Declaration * > &translationUnit );
+        /// Generates assignment operators, constructors, and destructor for aggregate types as required
+        void autogenerateRoutines( std::list< Declaration * > &translationUnit );
 
-    /// returns true if obj's name is the empty string and it has a bitfield width
-    bool isUnnamedBitfield( ObjectDecl * obj );
+        /// returns true if obj's name is the empty string and it has a bitfield width
+        bool isUnnamedBitfield( ObjectDecl * obj );
 
-    /// 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;
+        /// 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;
 
-    /// 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 >
+        /// 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 & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, 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 >
+        /// 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 & 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,
@@ -50 +49 @@
         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(true, true, true, false, true, false);
-            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 ) );
+                // 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 );
@@ -75 +73 @@
 
         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 & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
-        static UniqueName indexName( "_index" );
-
-        // for a flexible array member nothing is done -- user must define own assignment
-        if ( ! array->get_dimension() ) return ;
-
-        Expression * begin, * end, * update, * cmp;
-        if ( forward ) {
-            // generate: for ( int i = 0; i < N; ++i )
-            begin = new ConstantExpr( Constant::from_int( 0 ) );
-            end = array->get_dimension()->clone();
-            cmp = new NameExpr( "?<?" );
-            update = new NameExpr( "++?" );
-        } else {
-            // 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 ) ) );
-            end = new ConstantExpr( Constant::from_int( 0 ) );
-            cmp = new NameExpr( "?>=?" );
-            update = new NameExpr( "--?" );
         }
 
-        ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
+        /// 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 & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
+                static UniqueName indexName( "_index" );
 
-        UntypedExpr *cond = new UntypedExpr( cmp );
-        cond->get_args().push_back( new VariableExpr( index ) );
-        cond->get_args().push_back( end );
+                // for a flexible array member nothing is done -- user must define own assignment
+                if ( ! array->get_dimension() ) return ;
 
-        UntypedExpr *inc = new UntypedExpr( update );
-        inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+                Expression * begin, * end, * update, * cmp;
+                if ( forward ) {
+                        // generate: for ( int i = 0; i < N; ++i )
+                        begin = new ConstantExpr( Constant::from_int( 0 ) );
+                        end = array->get_dimension()->clone();
+                        cmp = new NameExpr( "?<?" );
+                        update = new NameExpr( "++?" );
+                } else {
+                        // 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 ) ) );
+                        end = new ConstantExpr( Constant::from_int( 0 ) );
+                        cmp = new NameExpr( "?>=?" );
+                        update = new NameExpr( "--?" );
+                }
 
-        UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
-        dstIndex->get_args().push_back( dstParam );
-        dstIndex->get_args().push_back( new VariableExpr( index ) );
-        dstParam = dstIndex;
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) );
 
-        // 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() );
+                UntypedExpr *cond = new UntypedExpr( cmp );
+                cond->get_args().push_back( new VariableExpr( index ) );
+                cond->get_args().push_back( end );
 
-        // 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 );
+                UntypedExpr *inc = new UntypedExpr( update );
+                inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
 
-        // 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 ) );
-        if ( listInit ) block->get_kids().push_back( listInit );
-        block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+                UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
+                dstIndex->get_args().push_back( dstParam );
+                dstIndex->get_args().push_back( new VariableExpr( index ) );
+                dstParam = dstIndex;
 
-        *out++ = block;
-    }
+                // 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() );
 
-    template< typename OutputIterator >
+                // 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 );
+
+                // 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 ) );
+                if ( listInit ) block->get_kids().push_back( listInit );
+                block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+
+                *out++ = block;
+        }
+
+        template< typename OutputIterator >
         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 );
-            return 0;
-        } else {
-            return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
+                        genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
+                        return 0;
+                } else {
+                        return genScalarCall( srcParam, dstParam, fname, 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
-    /// object being constructed. The function wraps constructor and destructor calls in an
-    /// ImplicitCtorDtorStmt node.
-    template< typename OutputIterator >
+        /// 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
+        /// object being constructed. The function wraps constructor and destructor calls in an
+        /// ImplicitCtorDtorStmt node.
+        template< typename OutputIterator >
         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 );
-        // unnamed bit fields are not copied as they cannot be accessed
-        if ( isUnnamedBitfield( obj ) ) return;
+                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
+                assert( obj );
+                // unnamed bit fields are not copied as they cannot be accessed
+                if ( isUnnamedBitfield( obj ) ) return;
 
-        bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
-        std::list< Statement * > stmts;
-        genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
+                bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
+                std::list< Statement * > stmts;
+                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
-        assert( stmts.size() <= 1 );
-        if ( stmts.size() == 1 ) {
-            Statement * callStmt = stmts.front();
-            if ( addCast ) {
-                // implicitly generated ctor/dtor calls should be wrapped
-                // so that later passes are aware they were generated.
-                // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
-                // because this causes the address to be taken at codegen, which is illegal in C.
-                callStmt = new ImplicitCtorDtorStmt( callStmt );
-            }
-            *out++ = callStmt;
+                // 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
+                assert( stmts.size() <= 1 );
+                if ( stmts.size() == 1 ) {
+                        Statement * callStmt = stmts.front();
+                        if ( addCast ) {
+                                // implicitly generated ctor/dtor calls should be wrapped
+                                // so that later passes are aware they were generated.
+                                // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
+                                // because this causes the address to be taken at codegen, which is illegal in C.
+                                callStmt = new ImplicitCtorDtorStmt( callStmt );
+                        }
+                        *out++ = callStmt;
+                }
         }
-    }
 } // namespace SymTab
-#endif // AUTOGEN_H
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
+