Index: src/CodeGen/FixNames.cc =================================================================== --- src/CodeGen/FixNames.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/CodeGen/FixNames.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Mar 16 07:50:30 2017 -// Update Count : 16 +// Last Modified On : Wed Jun 21 14:22:59 2017 +// Update Count : 19 // @@ -114,5 +114,5 @@ throw SemanticError("Main expected to have 0, 2 or 3 arguments\n", functionDecl); } - functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), "0") ) ) ); + functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new ConstantExpr( Constant::from_int( 0 ) ) ) ); CodeGen::FixMain::registerMain( functionDecl ); } Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/Common/PassVisitor.h (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -18,5 +18,14 @@ // Templated visitor type // To use declare a PassVisitor< YOUR VISITOR TYPE > -// The visitor type should specify the previsit/postvisit for types that are desired. +// The visitor type should specify the previsit/postvisit/premutate/postmutate for types that are desired. +// Note: previsit/postvisit/premutate/postmutate must be **public** members +// +// Several additional features are available through inheritance +// | WithTypeSubstitution - provides polymorphic TypeSubstitution * env for the current expression +// | WithStmtsToAdd - provides the ability to insert statements before or after the current statement by adding new statements into +// stmtsToAddBefore or stmtsToAddAfter respectively. +// | WithShortCircuiting - provides the ability to skip visiting child nodes; set skip_children to true if pre{visit,mutate} to skip visiting children +// | WithScopes - provides the ability to save/restore data like a LIFO stack; to save, call GuardValue with the variable to save, the variable +// will automatically be restored to its previous value after the corresponding postvisit/postmutate teminates. //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- template< typename pass_type > @@ -86,5 +95,4 @@ virtual void visit( ConstructorExpr * ctorExpr ) override final; virtual void visit( CompoundLiteralExpr *compLitExpr ) override final; - virtual void visit( UntypedValofExpr *valofExpr ) override final; virtual void visit( RangeExpr *rangeExpr ) override final; virtual void visit( UntypedTupleExpr *tupleExpr ) override final; @@ -172,5 +180,4 @@ virtual Expression* mutate( ConstructorExpr *ctorExpr ) override final; virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ) override final; - virtual Expression* mutate( UntypedValofExpr *valofExpr ) override final; virtual Expression* mutate( RangeExpr *rangeExpr ) override final; virtual Expression* mutate( UntypedTupleExpr *tupleExpr ) override final; Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/Common/PassVisitor.impl.h (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -6,8 +6,8 @@ call_previsit( node ); \ if( visit_children() ) { \ - reset_visit(); \ #define VISIT_END( node ) \ } \ + reset_visit(); \ call_postvisit( node ); \ @@ -17,8 +17,8 @@ call_premutate( node ); \ if( visit_children() ) { \ - reset_visit(); \ #define MUTATE_END( type, node ) \ } \ + reset_visit(); \ return call_postmutate< type * >( node ); \ @@ -159,45 +159,45 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( ObjectDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( FunctionDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( StructDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( UnionDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( EnumDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TraitDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TypeDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TypedefDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AsmDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -250,5 +250,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( AsmStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -257,5 +257,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( IfStmt * node ) { - VISIT_START( node ); + VISIT_START( node ); visitExpression( node->get_condition() ); @@ -268,5 +268,5 @@ template< typename pass_type > Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) { - MUTATE_START( node ); + MUTATE_START( node ); node->set_condition( mutateExpression( node->get_condition() ) ); @@ -281,5 +281,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( WhileStmt * node ) { - VISIT_START( node ); + VISIT_START( node ); visitExpression( node->get_condition() ); @@ -291,5 +291,5 @@ template< typename pass_type > Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) { - MUTATE_START( node ); + MUTATE_START( node ); node->set_condition( mutateExpression( node->get_condition() ) ); @@ -303,5 +303,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( ForStmt * node ) { - VISIT_START( node ); + VISIT_START( node ); acceptAll( node->get_initialization(), *this ); @@ -315,5 +315,5 @@ template< typename pass_type > Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) { - MUTATE_START( node ); + MUTATE_START( node ); mutateAll( node->get_initialization(), *this ); @@ -329,5 +329,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( SwitchStmt * node ) { - VISIT_START( node ); + VISIT_START( node ); visitExpression( node->get_condition() ); @@ -339,9 +339,9 @@ template< typename pass_type > Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) { - MUTATE_START( node ); - + MUTATE_START( node ); + node->set_condition( mutateExpression( node->get_condition() ) ); mutateStatementList( node->get_statements() ); - + MUTATE_END( Statement, node ); } @@ -351,9 +351,9 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( CaseStmt * node ) { - VISIT_START( node ); - + VISIT_START( node ); + visitExpression( node->get_condition() ); visitStatementList( node->get_statements() ); - + VISIT_END( node ); } @@ -361,9 +361,9 @@ template< typename pass_type > Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) { - MUTATE_START( node ); - + MUTATE_START( node ); + node->set_condition( mutateExpression( node->get_condition() ) ); mutateStatementList( node->get_statements() ); - + MUTATE_END( Statement, node ); } @@ -371,5 +371,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( BranchStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -425,5 +425,5 @@ node->set_block( maybeMutate( node->get_block(), *this ) ); mutateAll( node->get_catchers(), *this ); - + MUTATE_END( Statement, node ); } @@ -444,8 +444,8 @@ Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) { MUTATE_START( node ); - + node->set_body( mutateStatement( node->get_body() ) ); node->set_decl( maybeMutate( node->get_decl(), *this ) ); - + MUTATE_END( Statement, node ); } @@ -453,25 +453,25 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( FinallyStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( NullStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( DeclStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ApplicationExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -502,140 +502,135 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( NameExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( CastExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AddressExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( MemberExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( VariableExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ConstantExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( SizeofExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AlignofExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( OffsetofExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AttrExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( LogicalExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ConditionalExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( CommaExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TypeExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AsmExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ConstructorExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) { - VISIT_BODY( node ); -} - -template< typename pass_type > -void PassVisitor< pass_type >::visit( UntypedValofExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( RangeExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TupleExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -659,5 +654,5 @@ Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) { MUTATE_START( node ); - + // don't want statements from outer CompoundStmts to be added to this StmtExpr ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() ); @@ -672,85 +667,85 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( UniqueExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( VoidType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( BasicType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( PointerType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ArrayType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( FunctionType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( StructInstType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( UnionInstType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( EnumInstType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TraitInstType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TypeInstType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TupleType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TypeofType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AttrType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( VarArgsType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ZeroType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( OneType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -777,20 +772,20 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( ListInit * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ConstructorInit * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( Subrange * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( Constant * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -988,9 +983,4 @@ template< typename pass_type > -Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) { - MUTATE_BODY( Expression, node ); -} - -template< typename pass_type > Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) { MUTATE_BODY( Expression, node ); Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/GenPoly/Box.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat May 13 09:26:38 2017 -// Update Count : 341 +// Last Modified On : Wed Jun 21 15:49:59 2017 +// Update Count : 346 // @@ -341,5 +341,5 @@ Statement *makeAlignTo( Expression *lhs, Expression *rhs ) { // check that the lhs is zeroed out to the level of rhs - Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "1" ) ) ) ); + Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant::from_ulong( 1 ) ) ) ); // if not aligned, increment to alignment Expression *ifExpr = makeOp( "?+=?", lhs->clone(), makeOp( "?-?", rhs->clone(), ifCond->clone() ) ); @@ -384,6 +384,6 @@ // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size) - addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "0" ) ) ) ); - addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) ); + addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 0 ) ) ) ); + addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) ); unsigned long n_members = 0; bool firstMember = true; @@ -441,6 +441,6 @@ // calculate union layout in function body - addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) ); - addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) ); + addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) ); + addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) ); for ( std::list< Declaration* >::const_iterator member = unionDecl->get_members().begin(); member != unionDecl->get_members().end(); ++member ) { DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member ); @@ -1564,7 +1564,5 @@ /// Returns an index expression into the offset array for a type Expression *makeOffsetIndex( Type *objectType, long i ) { - std::stringstream offset_namer; - offset_namer << i; - ConstantExpr *fieldIndex = new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), offset_namer.str() ) ); + ConstantExpr *fieldIndex = new ConstantExpr( Constant::from_ulong( i ) ); UntypedExpr *fieldOffset = new UntypedExpr( new NameExpr( "?[?]" ) ); fieldOffset->get_args().push_back( new NameExpr( offsetofName( mangleType( objectType ) ) ) ); @@ -1779,5 +1777,5 @@ // all union members are at offset zero delete offsetofExpr; - return new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "0" ) ); + return new ConstantExpr( Constant::from_ulong( 0 ) ); } else return offsetofExpr; } Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/InitTweak/FixInit.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -10,6 +10,6 @@ // Created On : Wed Jan 13 16:29:30 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 17 09:13:47 2017 -// Update Count : 71 +// Last Modified On : Wed Jun 21 17:35:05 2017 +// Update Count : 74 // @@ -56,5 +56,5 @@ typedef std::unordered_map< int, int > UnqCount; - class InsertImplicitCalls { + class InsertImplicitCalls : public WithTypeSubstitution { public: /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which @@ -69,5 +69,4 @@ // collects environments for relevant nodes EnvMap & envMap; - TypeSubstitution * env; //Magically populated by the PassVisitor }; @@ -192,5 +191,5 @@ }; - class FixInit { + class FixInit : public WithStmtsToAdd { public: /// expand each object declaration to use its constructor after it is declared. @@ -200,5 +199,4 @@ std::list< Declaration * > staticDtorDecls; - std::list< Statement * > stmtsToAddAfter; // found by PassVisitor }; @@ -726,5 +724,5 @@ // static bool __objName_uninitialized = true BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool ); - SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators ); + SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ), noDesignators ); ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr ); isUninitializedVar->fixUniqueId(); @@ -733,5 +731,5 @@ UntypedExpr * setTrue = new UntypedExpr( new NameExpr( "?=?" ) ); setTrue->get_args().push_back( new VariableExpr( isUninitializedVar ) ); - setTrue->get_args().push_back( new ConstantExpr( Constant( boolType->clone(), "0" ) ) ); + setTrue->get_args().push_back( new ConstantExpr( Constant::from_int( 0 ) ) ); // generate body of if Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/Parser/ExpressionNode.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed May 17 21:31:01 2017 -// Update Count : 527 +// Last Modified On : Wed Jun 21 16:44:46 2017 +// Update Count : 541 // @@ -62,5 +62,5 @@ bool dec = true, Unsigned = false; // decimal, unsigned constant int size; // 0 => int, 1 => long, 2 => long long - unsigned long long v; // converted integral value + unsigned long long int v; // converted integral value size_t last = str.length() - 1; // last character of constant @@ -118,5 +118,5 @@ } // if - Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ) ); + Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str, v ) ); delete &str; // created by lex return ret; @@ -133,4 +133,7 @@ // floating-point constant has minimum of 2 characters: 1. or .1 size_t last = str.length() - 1; + double v; + + sscanf( str.c_str(), "%lg", &v ); if ( checkI( str[last] ) ) { // imaginary ? @@ -150,5 +153,5 @@ } // if - Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ) ); + Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str, v ) ); delete &str; // created by lex return ret; @@ -156,5 +159,5 @@ Expression *build_constantChar( const std::string & str ) { - Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ) ); + Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) ); delete &str; // created by lex return ret; @@ -164,8 +167,8 @@ // string should probably be a primitive type ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), - new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ), - toString( str.size()+1-2 ) ) ), // +1 for '\0' and -2 for '"' + new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"' false, false ); - ConstantExpr * ret = new ConstantExpr( Constant( at, str ) ); + // constant 0 is ignored for pure string value + ConstantExpr * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) ); delete &str; // created by lex return ret; @@ -173,5 +176,6 @@ Expression *build_constantZeroOne( const std::string & str ) { - Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str ) ); + Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str, + str == "0" ? (unsigned long long int)0 : (unsigned long long int)1 ) ); delete &str; // created by lex return ret; @@ -184,7 +188,5 @@ std::stringstream ss( str ); ss >> a >> dot >> b; - UntypedMemberExpr * ret = new UntypedMemberExpr( - new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::SignedInt ), toString( b ) ) ), - new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::SignedInt ), toString( a ) ) ) ); + UntypedMemberExpr * ret = new UntypedMemberExpr( new ConstantExpr( Constant::from_int( b ) ), new ConstantExpr( Constant::from_int( a ) ) ); delete &str; return ret; @@ -346,5 +348,5 @@ Expression *build_valexpr( StatementNode *s ) { - return new UntypedValofExpr( maybeMoveBuild< Statement >(s), nullptr ); + return new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(s) ) ); } Expression *build_typevalue( DeclarationNode *decl ) { Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/Parser/ParseNode.h (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -415,4 +415,6 @@ result->location = cur->location; * out++ = result; + } else { + assertf(false, "buildList unknown type"); } // if } catch( SemanticError &e ) { Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/Parser/StatementNode.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -175,6 +175,6 @@ Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) { - std::list< Statement * > branches; - buildMoveList< Statement, StatementNode >( catch_stmt, branches ); + std::list< CatchStmt * > branches; + buildMoveList< CatchStmt, StatementNode >( catch_stmt, branches ); CompoundStmt *tryBlock = safe_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt)); FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) ); Index: src/Parser/parseutility.cc =================================================================== --- src/Parser/parseutility.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/Parser/parseutility.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:30:39 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Aug 14 23:45:03 2016 -// Update Count : 3 +// Last Modified On : Wed Jun 21 15:33:41 2017 +// Update Count : 5 // @@ -26,5 +26,5 @@ UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) ); comparison->get_args().push_back( orig ); - comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) ) ); + comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0", (unsigned long long int)0 ) ) ); return new CastExpr( comparison, new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ); } Index: src/SymTab/Autogen.h =================================================================== --- src/SymTab/Autogen.h (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SymTab/Autogen.h (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -10,6 +10,6 @@ // Created On : Sun May 17 21:53:34 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 17 09:10:41 2017 -// Update Count : 9 +// Last Modified On : Wed Jun 21 17:25:26 2017 +// Update Count : 14 // @@ -25,153 +25,153 @@ 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, - // 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(); + // 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(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 ) ); - } - fExpr->get_args().push_back( dstParam ); + 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 ); + Statement * listInit = srcParam.buildListInit( fExpr ); - std::list< Expression * > args = *++srcParam; - fExpr->get_args().splice( fExpr->get_args().end(), args ); + std::list< Expression * > args = *++srcParam; + fExpr->get_args().splice( fExpr->get_args().end(), args ); - *out++ = new ExprStmt( noLabels, fExpr ); + *out++ = new ExprStmt( noLabels, fExpr ); - srcParam.clearArrayIndices(); + srcParam.clearArrayIndices(); - return listInit; + 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( "?= 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( "--?" ); } - /// 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" ); + ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list() ) ); - // for a flexible array member nothing is done -- user must define own assignment - if ( ! array->get_dimension() ) return ; + UntypedExpr *cond = new UntypedExpr( cmp ); + cond->get_args().push_back( new VariableExpr( index ) ); + cond->get_args().push_back( end ); - Expression * begin, * end, * update, * cmp; - if ( forward ) { - // generate: for ( int i = 0; i < 0; ++i ) - begin = new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) ); - end = array->get_dimension()->clone(); - cmp = new NameExpr( "?= 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( new OneType( emptyQualifiers ), "1" ) ) ); - end = new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) ); - cmp = new NameExpr( "?>=?" ); - update = new NameExpr( "--?" ); - } + UntypedExpr *inc = new UntypedExpr( update ); + inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) ); - ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list() ) ); + UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) ); + dstIndex->get_args().push_back( dstParam ); + dstIndex->get_args().push_back( new VariableExpr( index ) ); + dstParam = dstIndex; - UntypedExpr *cond = new UntypedExpr( cmp ); - cond->get_args().push_back( new VariableExpr( index ) ); - cond->get_args().push_back( end ); + // 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 *inc = new UntypedExpr( update ); - inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) ); + // 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 *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) ); - dstIndex->get_args().push_back( dstParam ); - dstIndex->get_args().push_back( new VariableExpr( index ) ); - dstParam = dstIndex; + // block containing for stmt and index variable + std::list 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 ) ); - // 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() ); + *out++ = block; + } - // 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 ); + 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 ); + } + } - // block containing for stmt and index variable - std::list 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 ) ); + /// 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( decl ); + assert( obj ); + // unnamed bit fields are not copied as they cannot be accessed + if ( isUnnamedBitfield( obj ) ) return; - *out++ = block; + 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; } - - 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 ); - } - } - - /// 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( 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 ); - - // 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 Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SymTab/Indexer.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -493,9 +493,4 @@ acceptNewScope( compLitExpr->get_result(), *this ); maybeAccept( compLitExpr->get_initializer(), *this ); - } - - void Indexer::visit( UntypedValofExpr *valofExpr ) { - acceptNewScope( valofExpr->get_result(), *this ); - maybeAccept( valofExpr->get_body(), *this ); } Index: src/SymTab/Indexer.h =================================================================== --- src/SymTab/Indexer.h (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SymTab/Indexer.h (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -69,5 +69,4 @@ virtual void visit( ConstructorExpr * ctorExpr ); virtual void visit( CompoundLiteralExpr *compLitExpr ); - virtual void visit( UntypedValofExpr *valofExpr ); virtual void visit( RangeExpr *rangeExpr ); virtual void visit( UntypedTupleExpr *tupleExpr ); Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SymTab/Validate.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -115,8 +115,8 @@ /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers. - class EnumAndPointerDecayPass final : public Visitor { - typedef Visitor Parent; - virtual void visit( EnumDecl *aggregateDecl ); - virtual void visit( FunctionType *func ); + class EnumAndPointerDecay { + public: + void previsit( EnumDecl *aggregateDecl ); + void previsit( FunctionType *func ); }; @@ -126,5 +126,4 @@ public: LinkReferenceToTypes( bool doDebug, const Indexer *indexer ); - private: using Parent::visit; void visit( EnumInstType *enumInst ) final; @@ -136,5 +135,5 @@ void visit( UnionDecl *unionDecl ) final; void visit( TypeInstType *typeInst ) final; - + private: const Indexer *indexer; @@ -147,11 +146,11 @@ }; - /// Replaces array and function types in forall lists by appropriate pointer type - class Pass3 final : public Indexer { + /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID. + class ForallPointerDecay final : public Indexer { typedef Indexer Parent; public: using Parent::visit; - Pass3( const Indexer *indexer ); - private: + ForallPointerDecay( const Indexer *indexer ); + virtual void visit( ObjectDecl *object ) override; virtual void visit( FunctionDecl *func ) override; @@ -160,5 +159,5 @@ }; - class ReturnChecker { + class ReturnChecker : public WithScopes { public: /// Checks that return statements return nothing if their return type is void @@ -167,10 +166,8 @@ private: void previsit( FunctionDecl * functionDecl ); - void postvisit( FunctionDecl * functionDecl ); void previsit( ReturnStmt * returnStmt ); typedef std::list< DeclarationWithType * > ReturnVals; ReturnVals returnVals; - std::stack< ReturnVals > returnValsStack; }; @@ -248,7 +245,7 @@ void validate( std::list< Declaration * > &translationUnit, bool doDebug ) { - EnumAndPointerDecayPass epc; + PassVisitor epc; LinkReferenceToTypes lrt( doDebug, 0 ); - Pass3 pass3( 0 ); + ForallPointerDecay fpd( 0 ); CompoundLiteral compoundliteral; PassVisitor genericParams; @@ -262,20 +259,20 @@ VerifyCtorDtorAssign::verify( translationUnit ); // must happen before autogen, because autogen examines existing ctor/dtors Concurrency::applyKeywords( translationUnit ); - autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecayPass + autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay Concurrency::implementMutexFuncs( translationUnit ); Concurrency::implementThreadStarter( translationUnit ); ReturnChecker::checkFunctionReturns( translationUnit ); compoundliteral.mutateDeclarationList( translationUnit ); - acceptAll( translationUnit, pass3 ); + acceptAll( translationUnit, fpd ); ArrayLength::computeLength( translationUnit ); } void validateType( Type *type, const Indexer *indexer ) { - EnumAndPointerDecayPass epc; + PassVisitor epc; LinkReferenceToTypes lrt( false, indexer ); - Pass3 pass3( indexer ); + ForallPointerDecay fpd( indexer ); type->accept( epc ); type->accept( lrt ); - type->accept( pass3 ); + type->accept( fpd ); } @@ -356,5 +353,5 @@ } - void EnumAndPointerDecayPass::visit( EnumDecl *enumDecl ) { + void EnumAndPointerDecay::previsit( EnumDecl *enumDecl ) { // Set the type of each member of the enumeration to be EnumConstant for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) { @@ -363,5 +360,4 @@ obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) ); } // for - Parent::visit( enumDecl ); } @@ -370,5 +366,5 @@ void fixFunctionList( DWTList & dwts, FunctionType * func ) { // the only case in which "void" is valid is where it is the only one in the list; then it should be removed - // entirely other fix ups are handled by the FixFunction class + // entirely. other fix ups are handled by the FixFunction class typedef typename DWTList::iterator DWTIterator; DWTIterator begin( dwts.begin() ), end( dwts.end() ); @@ -389,5 +385,5 @@ for ( ; i != end; ++i ) { FixFunction fixer; - *i = (*i )->acceptMutator( fixer ); + *i = (*i)->acceptMutator( fixer ); if ( fixer.get_isVoid() ) { throw SemanticError( "invalid type void in function type ", func ); @@ -398,9 +394,8 @@ } - void EnumAndPointerDecayPass::visit( FunctionType *func ) { + void EnumAndPointerDecay::previsit( FunctionType *func ) { // Fix up parameters and return types fixFunctionList( func->get_parameters(), func ); fixFunctionList( func->get_returnVals(), func ); - Visitor::visit( func ); } @@ -549,5 +544,5 @@ } - Pass3::Pass3( const Indexer *other_indexer ) : Indexer( false ) { + ForallPointerDecay::ForallPointerDecay( const Indexer *other_indexer ) : Indexer( false ) { if ( other_indexer ) { indexer = other_indexer; @@ -587,5 +582,5 @@ } - void Pass3::visit( ObjectDecl *object ) { + void ForallPointerDecay::visit( ObjectDecl *object ) { forallFixer( object->get_type() ); if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) { @@ -596,5 +591,5 @@ } - void Pass3::visit( FunctionDecl *func ) { + void ForallPointerDecay::visit( FunctionDecl *func ) { forallFixer( func->get_type() ); Parent::visit( func ); @@ -608,10 +603,6 @@ void ReturnChecker::previsit( FunctionDecl * functionDecl ) { - returnValsStack.push( returnVals ); + GuardValue( returnVals ); returnVals = functionDecl->get_functionType()->get_returnVals(); - } - void ReturnChecker::postvisit( __attribute__((unused)) FunctionDecl * functionDecl ) { - returnVals = returnValsStack.top(); - returnValsStack.pop(); } Index: src/SynTree/BaseSyntaxNode.h =================================================================== --- src/SynTree/BaseSyntaxNode.h (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SynTree/BaseSyntaxNode.h (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -24,5 +24,7 @@ CodeLocation location; - virtual void accept( Visitor & v ) = 0; // temporary -- needs to be here so that BaseSyntaxNode is polymorphic and can be dynamic_cast + virtual ~BaseSyntaxNode() {} + + virtual void accept( Visitor & v ) = 0; }; Index: src/SynTree/Constant.cc =================================================================== --- src/SynTree/Constant.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SynTree/Constant.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Jul 30 15:18:38 2015 -// Update Count : 12 +// Last Modified On : Wed Jun 21 16:44:48 2017 +// Update Count : 27 // @@ -21,9 +21,9 @@ #include "Type.h" -Constant::Constant( Type *type_, std::string value_ ) : type( type_ ), value( value_ ) {} +Constant::Constant( Type * type, std::string rep, unsigned long long val ) : type( type ), rep( rep ), val( val ) {} +Constant::Constant( Type * type, std::string rep, double val ) : type( type ), rep( rep ), val( val ) {} -Constant::Constant( const Constant &other ) { +Constant::Constant( const Constant &other ) : rep( other.rep ), val( other.val ) { type = other.type->clone(); - value = other.value; } @@ -31,19 +31,17 @@ Constant Constant::from_int( int i ) { - return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ) ); + return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ), (unsigned long long int)i ); } Constant Constant::from_ulong( unsigned long i ) { - return Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), std::to_string( i ) ); + return Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), std::to_string( i ), (unsigned long long int)i ); } Constant Constant::from_double( double d ) { - return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ) ); + return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ), d ); } -Constant *Constant::clone() const { assert( false ); return 0; } - void Constant::print( std::ostream &os ) const { - os << "(" << value; + os << "(" << rep << " " << val.ival; if ( type ) { os << ": "; Index: src/SynTree/Constant.h =================================================================== --- src/SynTree/Constant.h (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SynTree/Constant.h (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Jun 30 13:33:17 2016 -// Update Count : 6 +// Last Modified On : Wed Jun 21 16:44:48 2017 +// Update Count : 14 // @@ -23,12 +23,13 @@ class Constant { public: - Constant( Type *type, std::string value ); - Constant( const Constant &other ); + Constant( Type * type, std::string rep, unsigned long long val ); + Constant( Type * type, std::string rep, double val ); + Constant( const Constant & other ); virtual ~Constant(); - Type *get_type() { return type; } - void set_type( Type *newValue ) { type = newValue; } - std::string &get_value() { return value; } - void set_value( std::string newValue ) { value = newValue; } + Type * get_type() { return type; } + void set_type( Type * newValue ) { type = newValue; } + std::string & get_value() { return rep; } + void set_value( std::string newValue ) { rep = newValue; } /// generates an integer constant of the given int @@ -39,11 +40,16 @@ static Constant from_double( double d ); - virtual Constant *clone() const; - virtual void accept( Visitor &v ) { v.visit( this ); } - virtual Constant *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os ) const; + virtual void accept( Visitor & v ) { v.visit( this ); } + virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); } + virtual void print( std::ostream & os ) const; private: - Type *type; - std::string value; + Type * type; + std::string rep; + union Val { + unsigned long long ival; + double dval; + Val( unsigned long long ival ) : ival( ival ) {} + Val( double dval ) : dval( dval ) {} + } val; }; Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SynTree/Expression.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -288,6 +288,4 @@ } -// CastExpr *CastExpr::clone() const { return 0; } - void CastExpr::print( std::ostream &os, int indent ) const { os << "Cast of:" << std::endl << std::string( indent+2, ' ' ); @@ -355,5 +353,4 @@ } -//// is this right? It's cloning the member, but the member is a declaration so probably shouldn't be cloned... MemberExpr::MemberExpr( const MemberExpr &other ) : Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) { @@ -361,5 +358,5 @@ MemberExpr::~MemberExpr() { - // delete member; + // don't delete the member declaration, since it points somewhere else in the tree delete aggregate; } @@ -591,14 +588,4 @@ } -UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {} - -UntypedValofExpr::~UntypedValofExpr() { delete body; } - -void UntypedValofExpr::print( std::ostream &os, int indent ) const { - os << std::string( indent, ' ' ) << "Valof Expression: " << std::endl; - if ( get_body() != 0 ) - get_body()->print( os, indent + 2 ); -} - RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {} RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {} Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SynTree/Expression.h (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -226,5 +226,6 @@ }; -/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer +/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer. +/// Does not take ownership of member. class MemberExpr : public Expression { public: @@ -247,5 +248,6 @@ }; -/// VariableExpr represents an expression that simply refers to the value of a named variable +/// VariableExpr represents an expression that simply refers to the value of a named variable. +/// Does not take ownership of var. class VariableExpr : public Expression { public: @@ -598,22 +600,4 @@ }; -/// ValofExpr represents a GCC 'lambda expression' -class UntypedValofExpr : public Expression { - public: - UntypedValofExpr( Statement *_body, Expression *_aname = nullptr ) : Expression( _aname ), body ( _body ) {} - UntypedValofExpr( const UntypedValofExpr & other ); - virtual ~UntypedValofExpr(); - - Expression * get_value(); - Statement * get_body() const { return body; } - - virtual UntypedValofExpr * clone() const { return new UntypedValofExpr( * this ); } - virtual void accept( Visitor & v ) { v.visit( this ); } - virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); } - virtual void print( std::ostream & os, int indent = 0 ) const; - private: - Statement * body; -}; - /// RangeExpr represents a range e.g. '3 ... 5' or '1~10' class RangeExpr : public Expression { Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SynTree/Mutator.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -380,10 +380,4 @@ } -Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) { - valofExpr->set_env( maybeMutate( valofExpr->get_env(), *this ) ); - valofExpr->set_result( maybeMutate( valofExpr->get_result(), *this ) ); - return valofExpr; -} - Expression *Mutator::mutate( RangeExpr *rangeExpr ) { rangeExpr->set_env( maybeMutate( rangeExpr->get_env(), *this ) ); Index: src/SynTree/Mutator.h =================================================================== --- src/SynTree/Mutator.h (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SynTree/Mutator.h (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -78,5 +78,4 @@ virtual Expression* mutate( ConstructorExpr *ctorExpr ); virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ); - virtual Expression* mutate( UntypedValofExpr *valofExpr ); virtual Expression* mutate( RangeExpr *rangeExpr ); virtual Expression* mutate( UntypedTupleExpr *tupleExpr ); Index: src/SynTree/ObjectDecl.cc =================================================================== --- src/SynTree/ObjectDecl.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SynTree/ObjectDecl.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -56,7 +56,7 @@ if ( init ) { - os << " with initializer "; - init->print( os, indent ); - os << std::endl << std::string(indent, ' '); + os << " with initializer " << std::endl; + init->print( os, indent+2 ); + os << std::endl << std::string(indent+2, ' '); os << "maybeConstructed? " << init->get_maybeConstructed(); } // if Index: src/SynTree/Statement.cc =================================================================== --- src/SynTree/Statement.cc (revision 35df5608a5c44c381d42285cef800bb03ab0ce61) +++ src/SynTree/Statement.cc (revision 925b7f40bbde89981715553c5586e86c81e1fa80) @@ -313,5 +313,5 @@ } -TryStmt::TryStmt( std::list