Changes in / [e9a3b20b:06edda0]


Ignore:
Location:
src
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/FixNames.cc

    re9a3b20b r06edda0  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 21 14:22:59 2017
    13 // Update Count     : 19
     12// Last Modified On : Thu Mar 16 07:50:30 2017
     13// Update Count     : 16
    1414//
    1515
    … …  
    114114                                throw SemanticError("Main expected to have 0, 2 or 3 arguments\n", functionDecl);
    115115                        }
    116                         functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new ConstantExpr( Constant::from_int( 0 ) ) ) );
     116                        functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), "0") ) ) );
    117117                        CodeGen::FixMain::registerMain( functionDecl );
    118118                }

  • src/GenPoly/Box.cc

    re9a3b20b r06edda0  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 21 15:49:59 2017
    13 // Update Count     : 346
     12// Last Modified On : Sat May 13 09:26:38 2017
     13// Update Count     : 341
    1414//
    1515
    … …  
    341341        Statement *makeAlignTo( Expression *lhs, Expression *rhs ) {
    342342                // check that the lhs is zeroed out to the level of rhs
    343                 Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
     343                Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "1" ) ) ) );
    344344                // if not aligned, increment to alignment
    345345                Expression *ifExpr = makeOp( "?+=?", lhs->clone(), makeOp( "?-?", rhs->clone(), ifCond->clone() ) );
    … …  
    384384
    385385                // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size)
    386                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 0 ) ) ) );
    387                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
     386                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "0" ) ) ) );
     387                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
    388388                unsigned long n_members = 0;
    389389                bool firstMember = true;
    … …  
    441441
    442442                // calculate union layout in function body
    443                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
    444                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
     443                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
     444                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
    445445                for ( std::list< Declaration* >::const_iterator member = unionDecl->get_members().begin(); member != unionDecl->get_members().end(); ++member ) {
    446446                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
    … …  
    15641564                /// Returns an index expression into the offset array for a type
    15651565                Expression *makeOffsetIndex( Type *objectType, long i ) {
    1566                         ConstantExpr *fieldIndex = new ConstantExpr( Constant::from_ulong( i ) );
     1566                        std::stringstream offset_namer;
     1567                        offset_namer << i;
     1568                        ConstantExpr *fieldIndex = new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), offset_namer.str() ) );
    15671569                        UntypedExpr *fieldOffset = new UntypedExpr( new NameExpr( "?[?]" ) );
    15681570                        fieldOffset->get_args().push_back( new NameExpr( offsetofName( mangleType( objectType ) ) ) );
    … …  
    17771779                                // all union members are at offset zero
    17781780                                delete offsetofExpr;
    1779                                 return new ConstantExpr( Constant::from_ulong( 0 ) );
     1781                                return new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "0" ) );
    17801782                        } else return offsetofExpr;
    17811783                }

  • src/InitTweak/FixInit.cc

    re9a3b20b r06edda0  
    1010// Created On       : Wed Jan 13 16:29:30 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 21 17:35:05 2017
    13 // Update Count     : 74
     12// Last Modified On : Fri Mar 17 09:13:47 2017
     13// Update Count     : 71
    1414//
    1515
    … …  
    724724                                                // static bool __objName_uninitialized = true
    725725                                                BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
    726                                                 SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ), noDesignators );
     726                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
    727727                                                ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
    728728                                                isUninitializedVar->fixUniqueId();
    … …  
    731731                                                UntypedExpr * setTrue = new UntypedExpr( new NameExpr( "?=?" ) );
    732732                                                setTrue->get_args().push_back( new VariableExpr( isUninitializedVar ) );
    733                                                 setTrue->get_args().push_back( new ConstantExpr( Constant::from_int( 0 ) ) );
     733                                                setTrue->get_args().push_back( new ConstantExpr( Constant( boolType->clone(), "0" ) ) );
    734734
    735735                                                // generate body of if

  • src/Parser/ExpressionNode.cc

    re9a3b20b r06edda0  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 21 16:44:46 2017
    13 // Update Count     : 541
     12// Last Modified On : Wed May 17 21:31:01 2017
     13// Update Count     : 527
    1414//
    1515
    … …  
    6262        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
    6363        int size;                                                                                       // 0 => int, 1 => long, 2 => long long
    64         unsigned long long int v;                                                               // converted integral value
     64        unsigned long long v;                                                           // converted integral value
    6565        size_t last = str.length() - 1;                                         // last character of constant
    6666
    … …  
    118118        } // if
    119119
    120         Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str, v ) );
     120        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ) );
    121121        delete &str;                                                                            // created by lex
    122122        return ret;
    … …  
    133133        // floating-point constant has minimum of 2 characters: 1. or .1
    134134        size_t last = str.length() - 1;
    135         double v;
    136 
    137         sscanf( str.c_str(), "%lg", &v );
    138135
    139136        if ( checkI( str[last] ) ) {                                            // imaginary ?
    … …  
    153150        } // if
    154151
    155         Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str, v ) );
     152        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ) );
    156153        delete &str;                                                                            // created by lex
    157154        return ret;
    … …  
    159156
    160157Expression *build_constantChar( const std::string & str ) {
    161         Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
     158        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ) );
    162159        delete &str;                                                                            // created by lex
    163160        return ret;
    … …  
    167164        // string should probably be a primitive type
    168165        ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
    169                                                                    new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ),  // +1 for '\0' and -2 for '"'
     166                                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ),
     167                                                                                        toString( str.size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
    170168                                                                   false, false );
    171         // constant 0 is ignored for pure string value
    172         ConstantExpr * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) );
     169        ConstantExpr * ret = new ConstantExpr( Constant( at, str ) );
    173170        delete &str;                                                                            // created by lex
    174171        return ret;
    … …  
    176173
    177174Expression *build_constantZeroOne( const std::string & str ) {
    178         Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str,
    179                                                                                                    str == "0" ? (unsigned long long int)0 : (unsigned long long int)1 ) );
     175        Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str ) );
    180176        delete &str;                                                                            // created by lex
    181177        return ret;
    … …  
    188184        std::stringstream ss( str );
    189185        ss >> a >> dot >> b;
    190         UntypedMemberExpr * ret = new UntypedMemberExpr( new ConstantExpr( Constant::from_int( b ) ), new ConstantExpr( Constant::from_int( a ) ) );
     186        UntypedMemberExpr * ret = new UntypedMemberExpr(
     187                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::SignedInt ), toString( b ) ) ),
     188                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::SignedInt ), toString( a ) ) ) );
    191189        delete &str;
    192190        return ret;

  • src/Parser/parseutility.cc

    re9a3b20b r06edda0  
    1010// Created On       : Sat May 16 15:30:39 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 21 15:33:41 2017
    13 // Update Count     : 5
     12// Last Modified On : Sun Aug 14 23:45:03 2016
     13// Update Count     : 3
    1414//
    1515
    … …  
    2626        UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
    2727        comparison->get_args().push_back( orig );
    28         comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0", (unsigned long long int)0 ) ) );
     28        comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) ) );
    2929        return new CastExpr( comparison, new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
    3030}

  • src/SymTab/Autogen.h

    re9a3b20b r06edda0  
    1010// Created On       : Sun May 17 21:53:34 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 21 17:25:26 2017
    13 // Update Count     : 14
     12// Last Modified On : Fri Mar 17 09:10:41 2017
     13// Update Count     : 9
    1414//
    1515
    … …  
    2525
    2626namespace SymTab {
    27     /// Generates assignment operators, constructors, and destructor for aggregate types as required
    28     void autogenerateRoutines( std::list< Declaration * > &translationUnit );
     27        /// Generates assignment operators, constructors, and destructor for aggregate types as required
     28        void autogenerateRoutines( std::list< Declaration * > &translationUnit );
    2929
    30     /// returns true if obj's name is the empty string and it has a bitfield width
    31     bool isUnnamedBitfield( ObjectDecl * obj );
     30        /// returns true if obj's name is the empty string and it has a bitfield width
     31        bool isUnnamedBitfield( ObjectDecl * obj );
    3232
    33     /// size_t type - set when size_t typedef is seen. Useful in a few places,
    34     /// such as in determining array dimension type
    35     extern Type * SizeType;
     33        /// size_t type - set when size_t typedef is seen. Useful in a few places,
     34        /// such as in determining array dimension type
     35        extern Type * SizeType;
    3636
    37     /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
    38     template< typename OutputIterator >
     37        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
     38        template< typename OutputIterator >
    3939        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true );
    4040
    41     /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
    42     /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
    43     template< typename OutputIterator >
     41        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
     42        /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
     43        template< typename OutputIterator >
    4444        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
    45         // want to be able to generate assignment, ctor, and dtor generically,
    46         // so fname is either ?=?, ?{}, or ^?{}
    47         UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
     45                // want to be able to generate assignment, ctor, and dtor generically,
     46                // so fname is either ?=?, ?{}, or ^?{}
     47                UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
    4848
    49         // do something special for unnamed members
    50         dstParam = new AddressExpr( dstParam );
    51         if ( addCast ) {
    52             // cast to T* with qualifiers removed, so that qualified objects can be constructed
    53             // and destructed with the same functions as non-qualified objects.
    54             // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
    55             // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
    56             // remove lvalue as a qualifier, this can change to
    57             //   type->get_qualifiers() = Type::Qualifiers();
    58             assert( type );
    59             Type * castType = type->clone();
     49                // do something special for unnamed members
     50                dstParam = new AddressExpr( dstParam );
     51                if ( addCast ) {
     52                        // cast to T* with qualifiers removed, so that qualified objects can be constructed
     53                        // and destructed with the same functions as non-qualified objects.
     54                        // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
     55                        // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
     56                        // remove lvalue as a qualifier, this can change to
     57                        //   type->get_qualifiers() = Type::Qualifiers();
     58                        assert( type );
     59                        Type * castType = type->clone();
    6060//                      castType->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, false);
    61             castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
    62             castType->set_lvalue( true ); // xxx - might not need this
    63             dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
    64         }
    65         fExpr->get_args().push_back( dstParam );
     61                        castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
     62                        castType->set_lvalue( true ); // xxx - might not need this
     63                        dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
     64                }
     65                fExpr->get_args().push_back( dstParam );
    6666
    67         Statement * listInit = srcParam.buildListInit( fExpr );
     67                Statement * listInit = srcParam.buildListInit( fExpr );
    6868
    69         std::list< Expression * > args = *++srcParam;
    70         fExpr->get_args().splice( fExpr->get_args().end(), args );
     69                std::list< Expression * > args = *++srcParam;
     70                fExpr->get_args().splice( fExpr->get_args().end(), args );
    7171
    72         *out++ = new ExprStmt( noLabels, fExpr );
     72                *out++ = new ExprStmt( noLabels, fExpr );
    7373
    74         srcParam.clearArrayIndices();
     74                srcParam.clearArrayIndices();
    7575
    76         return listInit;
    77     }
    78 
    79     /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
    80     /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
    81     template< typename OutputIterator >
    82         void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
    83         static UniqueName indexName( "_index" );
    84 
    85         // for a flexible array member nothing is done -- user must define own assignment
    86         if ( ! array->get_dimension() ) return ;
    87 
    88         Expression * begin, * end, * update, * cmp;
    89         if ( forward ) {
    90             // generate: for ( int i = 0; i < N; ++i )
    91             begin = new ConstantExpr( Constant::from_int( 0 ) );
    92             end = array->get_dimension()->clone();
    93             cmp = new NameExpr( "?<?" );
    94             update = new NameExpr( "++?" );
    95         } else {
    96             // generate: for ( int i = N-1; i >= 0; --i )
    97             begin = new UntypedExpr( new NameExpr( "?-?" ) );
    98             ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
    99             ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
    100             end = new ConstantExpr( Constant::from_int( 0 ) );
    101             cmp = new NameExpr( "?>=?" );
    102             update = new NameExpr( "--?" );
     76                return listInit;
    10377        }
    10478
    105         ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
     79        /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
     80        /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
     81        template< typename OutputIterator >
     82        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
     83                static UniqueName indexName( "_index" );
    10684
    107         UntypedExpr *cond = new UntypedExpr( cmp );
    108         cond->get_args().push_back( new VariableExpr( index ) );
    109         cond->get_args().push_back( end );
     85                // for a flexible array member nothing is done -- user must define own assignment
     86                if ( ! array->get_dimension() ) return ;
    11087
    111         UntypedExpr *inc = new UntypedExpr( update );
    112         inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
     88                Expression * begin, * end, * update, * cmp;
     89                if ( forward ) {
     90                        // generate: for ( int i = 0; i < 0; ++i )
     91                        begin = new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) );
     92                        end = array->get_dimension()->clone();
     93                        cmp = new NameExpr( "?<?" );
     94                        update = new NameExpr( "++?" );
     95                } else {
     96                        // generate: for ( int i = N-1; i >= 0; --i )
     97                        begin = new UntypedExpr( new NameExpr( "?-?" ) );
     98                        ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
     99                        ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant( new OneType( emptyQualifiers ), "1" ) ) );
     100                        end = new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) );
     101                        cmp = new NameExpr( "?>=?" );
     102                        update = new NameExpr( "--?" );
     103                }
    113104
    114         UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
    115         dstIndex->get_args().push_back( dstParam );
    116         dstIndex->get_args().push_back( new VariableExpr( index ) );
    117         dstParam = dstIndex;
     105                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
    118106
    119         // srcParam must keep track of the array indices to build the
    120         // source parameter and/or array list initializer
    121         srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
     107                UntypedExpr *cond = new UntypedExpr( cmp );
     108                cond->get_args().push_back( new VariableExpr( index ) );
     109                cond->get_args().push_back( end );
    122110
    123         // for stmt's body, eventually containing call
    124         CompoundStmt * body = new CompoundStmt( noLabels );
    125         Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
     111                UntypedExpr *inc = new UntypedExpr( update );
     112                inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
    126113
    127         // block containing for stmt and index variable
    128         std::list<Statement *> initList;
    129         CompoundStmt * block = new CompoundStmt( noLabels );
    130         block->get_kids().push_back( new DeclStmt( noLabels, index ) );
    131         if ( listInit ) block->get_kids().push_back( listInit );
    132         block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
     114                UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
     115                dstIndex->get_args().push_back( dstParam );
     116                dstIndex->get_args().push_back( new VariableExpr( index ) );
     117                dstParam = dstIndex;
    133118
    134         *out++ = block;
    135     }
     119                // srcParam must keep track of the array indices to build the
     120                // source parameter and/or array list initializer
     121                srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
    136122
    137     template< typename OutputIterator >
     123                // for stmt's body, eventually containing call
     124                CompoundStmt * body = new CompoundStmt( noLabels );
     125                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
     126
     127                // block containing for stmt and index variable
     128                std::list<Statement *> initList;
     129                CompoundStmt * block = new CompoundStmt( noLabels );
     130                block->get_kids().push_back( new DeclStmt( noLabels, index ) );
     131                if ( listInit ) block->get_kids().push_back( listInit );
     132                block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
     133
     134                *out++ = block;
     135        }
     136
     137        template< typename OutputIterator >
    138138        Statement * genCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
    139         if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
    140             genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
    141             return 0;
    142         } else {
    143             return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
     139                if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
     140                        genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
     141                        return 0;
     142                } else {
     143                        return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
     144                }
    144145        }
    145     }
    146146
    147     /// inserts into out a generated call expression to function fname with arguments dstParam
    148     /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
    149     /// object being constructed. The function wraps constructor and destructor calls in an
    150     /// ImplicitCtorDtorStmt node.
    151     template< typename OutputIterator >
     147        /// inserts into out a generated call expression to function fname with arguments dstParam
     148        /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
     149        /// object being constructed. The function wraps constructor and destructor calls in an
     150        /// ImplicitCtorDtorStmt node.
     151        template< typename OutputIterator >
    152152        void genImplicitCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
    153         ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
    154         assert( obj );
    155         // unnamed bit fields are not copied as they cannot be accessed
    156         if ( isUnnamedBitfield( obj ) ) return;
     153                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
     154                assert( obj );
     155                // unnamed bit fields are not copied as they cannot be accessed
     156                if ( isUnnamedBitfield( obj ) ) return;
    157157
    158         bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
    159         std::list< Statement * > stmts;
    160         genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
     158                bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
     159                std::list< Statement * > stmts;
     160                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
    161161
    162         // 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
    163         assert( stmts.size() <= 1 );
    164         if ( stmts.size() == 1 ) {
    165             Statement * callStmt = stmts.front();
    166             if ( addCast ) {
    167                 // implicitly generated ctor/dtor calls should be wrapped
    168                 // so that later passes are aware they were generated.
    169                 // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
    170                 // because this causes the address to be taken at codegen, which is illegal in C.
    171                 callStmt = new ImplicitCtorDtorStmt( callStmt );
    172             }
    173             *out++ = callStmt;
     162                // 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
     163                assert( stmts.size() <= 1 );
     164                if ( stmts.size() == 1 ) {
     165                        Statement * callStmt = stmts.front();
     166                        if ( addCast ) {
     167                                // implicitly generated ctor/dtor calls should be wrapped
     168                                // so that later passes are aware they were generated.
     169                                // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
     170                                // because this causes the address to be taken at codegen, which is illegal in C.
     171                                callStmt = new ImplicitCtorDtorStmt( callStmt );
     172                        }
     173                        *out++ = callStmt;
     174                }
    174175        }
    175     }
    176176} // namespace SymTab
    177177#endif // AUTOGEN_H

  • src/SynTree/Constant.cc

    re9a3b20b r06edda0  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 21 16:44:48 2017
    13 // Update Count     : 27
     12// Last Modified On : Thu Jul 30 15:18:38 2015
     13// Update Count     : 12
    1414//
    1515
    … …  
    2121#include "Type.h"
    2222
    23 Constant::Constant( Type * type, std::string rep, unsigned long long val ) : type( type ), rep( rep ), val( val ) {}
    24 Constant::Constant( Type * type, std::string rep, double val ) : type( type ), rep( rep ), val( val ) {}
     23Constant::Constant( Type *type_, std::string value_ ) : type( type_ ), value( value_ ) {}
    2524
    26 Constant::Constant( const Constant &other ) : rep( other.rep ), val( other.val ) {
     25Constant::Constant( const Constant &other ) {
    2726        type = other.type->clone();
     27        value = other.value;
    2828}
    2929
    … …  
    3131
    3232Constant Constant::from_int( int i ) {
    33         return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ), (unsigned long long int)i );
     33        return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ) );
    3434}
    3535
    3636Constant Constant::from_ulong( unsigned long i ) {
    37         return Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), std::to_string( i ), (unsigned long long int)i );
     37        return Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), std::to_string( i ) );
    3838}
    3939
    4040Constant Constant::from_double( double d ) {
    41         return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ), d );
     41        return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ) );
    4242}
    4343
     44Constant *Constant::clone() const { assert( false ); return 0; }
     45
    4446void Constant::print( std::ostream &os ) const {
    45         os << "(" << rep << " " << val.ival;
     47        os << "(" << value;
    4648        if ( type ) {
    4749                os << ": ";

  • src/SynTree/Constant.h

    re9a3b20b r06edda0  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 21 16:44:48 2017
    13 // Update Count     : 14
     12// Last Modified On : Thu Jun 30 13:33:17 2016
     13// Update Count     : 6
    1414//
    1515
    … …  
    2323class Constant {
    2424  public:
    25         Constant( Type * type, std::string rep, unsigned long long val );
    26         Constant( Type * type, std::string rep, double val );
    27         Constant( const Constant & other );
     25        Constant( Type *type, std::string value );
     26        Constant( const Constant &other );
    2827        virtual ~Constant();
    2928
    30         Type * get_type() { return type; }
    31         void set_type( Type * newValue ) { type = newValue; }
    32         std::string & get_value() { return rep; }
    33         void set_value( std::string newValue ) { rep = newValue; }
     29        Type *get_type() { return type; }
     30        void set_type( Type *newValue ) { type = newValue; }
     31        std::string &get_value() { return value; }
     32        void set_value( std::string newValue ) { value = newValue; }
    3433
    3534        /// generates an integer constant of the given int
    … …  
    4039        static Constant from_double( double d );
    4140
    42         virtual void accept( Visitor & v ) { v.visit( this ); }
    43         virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    44         virtual void print( std::ostream & os ) const;
     41        virtual Constant *clone() const;
     42        virtual void accept( Visitor &v ) { v.visit( this ); }
     43        virtual Constant *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     44        virtual void print( std::ostream &os ) const;
    4545  private:
    46         Type * type;
    47         std::string rep;
    48         union Val {
    49                 unsigned long long ival;
    50                 double dval;
    51                 Val( unsigned long long ival ) : ival( ival ) {}
    52                 Val( double dval ) : dval( dval ) {}
    53         } val;
     46        Type *type;
     47        std::string value;
    5448};
    5549

  • src/Tuples/TupleExpansion.cc

    re9a3b20b r06edda0  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 21 17:35:04 2017
    13 // Update Count     : 19
     12// Last Modified On : Thu Mar 16 08:05:17 2017
     13// Update Count     : 15
    1414//
    1515
    … …  
    191191                                commaExpr->set_arg1( nullptr );
    192192                        }
    193                         ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ),
    194                                                                                                         new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ), noDesignators ) );
     193                        BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
     194                        ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) );
    195195                        addDeclaration( finished );
    196196                        // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
    197197                        // This pattern ensures that each unique expression is evaluated once, regardless of evaluation order of the generated C code.
    198                         Expression * assignFinished = UntypedExpr::createAssign( new VariableExpr(finished), new ConstantExpr( Constant::from_int( 1 ) ) );
     198                        Expression * assignFinished = UntypedExpr::createAssign( new VariableExpr(finished), new ConstantExpr( Constant( boolType->clone(), "1" ) ) );
    199199                        ConditionalExpr * condExpr = new ConditionalExpr( new VariableExpr( finished ), var->clone(),
    200200                                new CommaExpr( new CommaExpr( assignUnq, assignFinished ), var->clone() ) );
Note: See TracChangeset for help on using the changeset viewer.