Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 71f4e4f59e25d1ae31af19227f4d2a8a9365bac7) +++ src/CodeGen/CodeGenerator.cc (revision f1e012b7aa1aaea6aa2dde9bcb3b0e83dcf13824) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Wed Jan 13 16:26:59 2016 -// Update Count : 234 +// Last Modified On : Tue Jan 19 13:15:44 2016 +// Update Count : 251 // @@ -258,9 +258,17 @@ case OT_CALL: - case OT_CTOR: - case OT_DTOR: // there are no intrinsic definitions of the function call operator or constructors or destructors assert( false ); break; + + case OT_CTOR: + // intrinsic constructors should never be called directly - they should be transformed back into Initializer nodes + assert(false); + break; + + case OT_DTOR: + // intrinsic destructors do nothing - don't generate any code + output << " // " << dynamic_cast(applicationExpr->get_function())->get_var()->get_name() << endl; + break; case OT_PREFIX: @@ -279,4 +287,5 @@ output << opInfo.symbol; break; + case OT_INFIX: @@ -324,7 +333,10 @@ case OT_CALL: + assert( false ); + case OT_CTOR: case OT_DTOR: - assert( false ); + // intrinsic constructors should never be called + // intrinsic destructors do nothing break; Index: src/GenPoly/Specialize.cc =================================================================== --- src/GenPoly/Specialize.cc (revision 71f4e4f59e25d1ae31af19227f4d2a8a9365bac7) +++ src/GenPoly/Specialize.cc (revision f1e012b7aa1aaea6aa2dde9bcb3b0e83dcf13824) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// Specialize.cc -- +// Specialize.cc -- // // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Tue Sep 22 14:04:13 2015 -// Update Count : 15 +// Last Modified On : Tue Jan 19 10:40:37 2016 +// Update Count : 23 // @@ -140,6 +140,7 @@ return new AddressExpr( new VariableExpr( thunkFunc ) ); } - + Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) { + assert( actual->get_results().size() >= 1 ); // using front, should have this assert if ( needsSpecialization( formalType, actual->get_results().front(), env ) ) { FunctionType *funType; @@ -197,4 +198,5 @@ Expression * Specialize::mutate( CastExpr *castExpr ) { + assert( castExpr->get_results().size() >= 1 && "Check that functions with void return aren't returning a value" ); castExpr->get_arg()->acceptMutator( *this ); Expression *specialized = doSpecialization( castExpr->get_results().front(), castExpr->get_arg() ); Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 71f4e4f59e25d1ae31af19227f4d2a8a9365bac7) +++ src/InitTweak/FixInit.cc (revision f1e012b7aa1aaea6aa2dde9bcb3b0e83dcf13824) @@ -10,6 +10,6 @@ // Created On : Wed Jan 13 16:29:30 2016 // Last Modified By : Rob Schluntz -// Last Modified On : Wed Jan 13 16:45:37 2016 -// Update Count : 17 +// Last Modified On : Tue Jan 19 13:25:13 2016 +// Update Count : 27 // @@ -35,4 +35,6 @@ virtual ObjectDecl * mutate( ObjectDecl *objDecl ); + + virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ); }; @@ -50,5 +52,5 @@ ObjectDecl *FixInit::mutate( ObjectDecl *objDecl ) { if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) { - // a decision should have been made by the resolver, so either ctor is NULL or init is NULL + // a decision should have been made by the resolver, so ctor and init are not both non-NULL assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() ); if ( Expression * ctor = ctorInit->get_ctor() ) { @@ -61,6 +63,6 @@ ctorInit->set_init( NULL ); } else { - // one of them should be non-NULL - assert( ctorInit->get_ctor() || ctorInit->get_init() ); + // no constructor and no initializer, which is okay + objDecl->set_init( NULL ); } delete ctorInit; @@ -68,4 +70,24 @@ return objDecl; } + + CompoundStmt * FixInit::mutate( CompoundStmt * compoundStmt ) { + std::list< Statement * > & statements = compoundStmt->get_kids(); + for ( std::list< Statement * >::iterator it = statements.begin(); it != statements.end(); ++it ) { + // remove if instrinsic destructor statement + // xxx - test user manually calling intrinsic functions - what happens? + if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( *it ) ) { + if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( exprStmt->get_expr() ) ) { + if ( VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() ) ) { + if ( function->get_var()->get_name() == "^?{}" && function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) { + statements.erase(it++); + } + } + } + } + } + // mutate non-destructor statements + return Mutator::mutate( compoundStmt ); + } + } // namespace InitTweak Index: src/InitTweak/RemoveInit.cc =================================================================== --- src/InitTweak/RemoveInit.cc (revision 71f4e4f59e25d1ae31af19227f4d2a8a9365bac7) +++ src/InitTweak/RemoveInit.cc (revision f1e012b7aa1aaea6aa2dde9bcb3b0e83dcf13824) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Wed Jan 13 15:19:35 2016 -// Update Count : 154 +// Last Modified On : Tue Jan 19 11:12:49 2016 +// Update Count : 165 // @@ -59,4 +59,6 @@ static void generateCtorDtor( std::list< Declaration * > &translationUnit ); + CtorDtor() : inFunction( false ) {} + virtual ObjectDecl * mutate( ObjectDecl * ); virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ); @@ -71,4 +73,5 @@ protected: + bool inFunction; // to be added before block ends - use push_front so order is correct @@ -93,5 +96,6 @@ if (objDecl->get_init() && dynamic_cast(objDecl->get_type())) { if (SingleInit * single = dynamic_cast(objDecl->get_init())) { - UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); + // xxx this can be more complicated - consider ListInit + UntypedExpr *assign = new UntypedExpr( new NameExpr( "?{}" ) ); assign->get_args().push_back( new AddressExpr (new NameExpr( objDecl->get_name() ) ) ); assign->get_args().push_back( single->get_value()->clone() ); @@ -107,4 +111,5 @@ // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address // is being returned + // xxx - this should construct rather than assign if ( returnStmt->get_expr() && returnVals.size() == 1 && funcName != "?=?" && ! returnVals.front()->get_type()->get_isLvalue() ) { ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, returnVals.front()->get_type()->clone(), 0 ); @@ -186,12 +191,18 @@ // hands off if designated or if @= if ( tryConstruct( objDecl ) ) { - Expression * ctor = makeCtorDtorExpr( "?{}", objDecl, makeInitList( objDecl->get_init() ) ); - Expression * dtor = makeCtorDtorExpr( "^?{}", objDecl, std::list< Expression * >() ); - - // need to remember init expression, in case no ctors exist - // if ctor does exist, want to use ctor expression instead of init - // push this decision to the resolver - objDecl->set_init( new ConstructorInit( ctor, objDecl->get_init() ) ); - destructorStmts.push_front( new ExprStmt( noLabels, dtor ) ); + if ( inFunction ) { + Expression * ctor = makeCtorDtorExpr( "?{}", objDecl, makeInitList( objDecl->get_init() ) ); + Expression * dtor = makeCtorDtorExpr( "^?{}", objDecl, std::list< Expression * >() ); + + // need to remember init expression, in case no ctors exist + // if ctor does exist, want to use ctor expression instead of init + // push this decision to the resolver + objDecl->set_init( new ConstructorInit( ctor, objDecl->get_init() ) ); + destructorStmts.push_front( new ExprStmt( noLabels, dtor ) ); + } else { + // xxx - find a way to construct/destruct globals + // hack: implicit "static" initialization routine for each struct type? or something similar? + // --ties into module system + } } return objDecl; @@ -200,6 +211,9 @@ DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) { // parameters should not be constructed and destructed, so don't mutate FunctionType + bool oldInFunc = inFunction; mutateAll( functionDecl->get_oldDecls(), *this ); + inFunction = true; functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) ); + inFunction = oldInFunc; return functionDecl; } Index: src/MakeLibCfa.cc =================================================================== --- src/MakeLibCfa.cc (revision 71f4e4f59e25d1ae31af19227f4d2a8a9365bac7) +++ src/MakeLibCfa.cc (revision f1e012b7aa1aaea6aa2dde9bcb3b0e83dcf13824) @@ -10,6 +10,6 @@ // Created On : Sat May 16 10:33:33 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Thu Jan 07 13:34:39 2016 -// Update Count : 20 +// Last Modified On : Tue Jan 19 13:20:26 2016 +// Update Count : 40 // @@ -54,8 +54,14 @@ assert( param != funcDecl->get_functionType()->get_parameters().end() ); - if ( (*param)->get_name() == "" ) { - (*param)->set_name( paramNamer.newName() ); - (*param)->set_linkage( LinkageSpec::C ); - } // if + for ( ; param != funcDecl->get_functionType()->get_parameters().end(); ++param ) { + if ( (*param)->get_name() == "" ) { + (*param)->set_name( paramNamer.newName() ); + (*param)->set_linkage( LinkageSpec::C ); + } + newExpr->get_args().push_back( new VariableExpr( *param ) ); + } // for + + funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) ); + newDecls.push_back( funcDecl ); switch ( opInfo.type ) { @@ -65,18 +71,28 @@ case CodeGen::OT_POSTFIX: case CodeGen::OT_INFIX: - newExpr->get_args().push_back( new VariableExpr( *param ) ); - break; case CodeGen::OT_PREFIXASSIGN: case CodeGen::OT_POSTFIXASSIGN: case CodeGen::OT_INFIXASSIGN: - { - newExpr->get_args().push_back( new VariableExpr( *param ) ); - // UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) ); - // deref->get_args().push_back( new VariableExpr( *param ) ); - // newExpr->get_args().push_back( deref ); + funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) ); break; - } case CodeGen::OT_CTOR: + // ctors don't return a value + if ( funcDecl->get_functionType()->get_parameters().size() == 1 ) { + // intrinsic default constructors should do nothing + // delete newExpr; + break; + } else { + assert( funcDecl->get_functionType()->get_parameters().size() == 2 ); + // anything else is a single parameter constructor that is effectively a C-style assignment + // delete newExpr->get_function(); + assert(newExpr->get_args().size()==2); + newExpr->set_function( new NameExpr( "?=?" ) ); + funcDecl->get_statements()->get_kids().push_back( new ExprStmt( std::list< Label >(), newExpr ) ); + } + break; case CodeGen::OT_DTOR: + // intrinsic destructors should do nothing + // delete newExpr; + break; case CodeGen::OT_CONSTANT: case CodeGen::OT_LABELADDRESS: @@ -84,15 +100,4 @@ assert( false ); } // switch - - for ( param++; param != funcDecl->get_functionType()->get_parameters().end(); ++param ) { - if ( (*param)->get_name() == "" ) { - (*param)->set_name( paramNamer.newName() ); - (*param)->set_linkage( LinkageSpec::C ); - } - newExpr->get_args().push_back( new VariableExpr( *param ) ); - } // for - funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) ); - funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) ); - newDecls.push_back( funcDecl ); } @@ -107,8 +112,2 @@ } } // namespace LibCfa - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 71f4e4f59e25d1ae31af19227f4d2a8a9365bac7) +++ src/Parser/TypeData.cc (revision f1e012b7aa1aaea6aa2dde9bcb3b0e83dcf13824) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// TypeData.cc -- +// TypeData.cc -- // // Author : Rodolfo G. Esteves // Created On : Sat May 16 15:12:51 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jul 14 14:57:23 2015 -// Update Count : 32 +// Last Modified By : Rob Schluntz +// Last Modified On : Thu Jan 14 10:43:42 2016 +// Update Count : 36 // @@ -436,4 +436,6 @@ for ( std::list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) { if ( (*i)->get_kind() == TypeDecl::Any ) { + // add assertion parameters to `type' tyvars + // add: T * ?=?(T *, T) FunctionType *assignType = new FunctionType( Type::Qualifiers(), false ); assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) ); @@ -441,4 +443,14 @@ assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) ); (*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false, false ) ); + + // add: void ?{}(T *) + FunctionType *ctorType = new FunctionType( Type::Qualifiers(), false ); + ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) ); + (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, 0, false, false ) ); + + // add: void ^?{}(T *) + FunctionType *dtorType = new FunctionType( Type::Qualifiers(), false ); + dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) ); + (*i)->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, 0, false, false ) ); } // if } // for Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 71f4e4f59e25d1ae31af19227f4d2a8a9365bac7) +++ src/ResolvExpr/Resolver.cc (revision f1e012b7aa1aaea6aa2dde9bcb3b0e83dcf13824) @@ -10,6 +10,6 @@ // Created On : Sun May 17 12:17:01 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Wed Jan 13 16:23:51 2016 -// Update Count : 186 +// Last Modified On : Thu Jan 14 16:45:32 2016 +// Update Count : 203 // @@ -60,4 +60,5 @@ void resolveAggrInit( AggregateDecl *, InitIterator &, InitIterator & ); void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & ); + void fallbackInit( ConstructorInit * ctorInit ); std::list< Type * > functionReturn; @@ -467,17 +468,33 @@ } + // ConstructorInit - fall back on C-style initializer + void Resolver::fallbackInit( ConstructorInit * ctorInit ) { + // could not find valid constructor, or found an intrinsic constructor + // fall back on C-style initializer + delete ctorInit->get_ctor(); + ctorInit->set_ctor( NULL ); + maybeAccept( ctorInit->get_init(), *this ); + } + void Resolver::visit( ConstructorInit *ctorInit ) { TypeEnvironment env; AlternativeFinder finder( *this, env ); finder.find( ctorInit->get_ctor() ); + if ( finder.get_alternatives().size() == 0 ) { - // could not find valid constructor - delete ctorInit->get_ctor(); - ctorInit->set_ctor( NULL ); - - maybeAccept( ctorInit->get_init(), *this ); + fallbackInit( ctorInit ); } else if ( finder.get_alternatives().size() == 1 ) { + Alternative &choice = finder.get_alternatives().front(); + if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( choice.expr ) ) { + if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) { + if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) { + // if the constructor that was found is intrinsic, reset to C-style + // initializer so that code generation is easy to handle + fallbackInit( ctorInit ); + return; + } + } + } // found a constructor - can get rid of C-style initializer - Alternative &choice = finder.get_alternatives().front(); Expression *newExpr = choice.expr->clone(); finishExpr( newExpr, choice.env ); Index: src/libcfa/prelude.cf =================================================================== --- src/libcfa/prelude.cf (revision 71f4e4f59e25d1ae31af19227f4d2a8a9365bac7) +++ src/libcfa/prelude.cf (revision f1e012b7aa1aaea6aa2dde9bcb3b0e83dcf13824) @@ -1,8 +1,8 @@ -// -*- Mode: C -*- -// +// -*- Mode: C -*- +// // Copyright (C) Glen Ditchfield 1994, 1999 -// +// // prelude.cf -- Standard Cforall Preample for C99 -// +// // Author : Glen Ditchfield // Created On : Sat Nov 29 07:23:41 2014 @@ -116,11 +116,11 @@ forall( ftype FT ) lvalue FT *?( FT * ); -_Bool +?( _Bool ), -?( _Bool ), ~?( _Bool ); -signed int +?( signed int ), -?( signed int ), ~?( signed int ); -unsigned int +?( unsigned int ), -?( unsigned int ), ~?( unsigned int ); -signed long int +?( signed long int ), -?( signed long int ), ~?( signed long int ); -unsigned long int +?( unsigned long int ), -?( unsigned long int ), ~?( unsigned long int ); -signed long long int +?( signed long long int ), -?( signed long long int ), ~?( signed long long int ); -unsigned long long int +?( unsigned long long int ), -?( unsigned long long int ), ~?( unsigned long long int ); +_Bool +?( _Bool ), -?( _Bool ), ~?( _Bool ); +signed int +?( signed int ), -?( signed int ), ~?( signed int ); +unsigned int +?( unsigned int ), -?( unsigned int ), ~?( unsigned int ); +signed long int +?( signed long int ), -?( signed long int ), ~?( signed long int ); +unsigned long int +?( unsigned long int ), -?( unsigned long int ), ~?( unsigned long int ); +signed long long int +?( signed long long int ), -?( signed long long int ), ~?( signed long long int ); +unsigned long long int +?( unsigned long long int ), -?( unsigned long long int ), ~?( unsigned long long int ); float +?( float ), -?( float ); double +?( double ), -?( double ); @@ -626,2 +626,216 @@ ?+=?( long double _Complex *, long double _Complex ), ?+=?( volatile long double _Complex *, long double _Complex ), ?-=?( long double _Complex *, long double _Complex ), ?-=?( volatile long double _Complex *, long double _Complex ); + + + + + +// ------------------------------------------------------------ +// +// Section ??? Constructors and Destructors +// +// ------------------------------------------------------------ + +// default ctor +void ?{}( _Bool * ), ?{}( volatile _Bool * ); +void ?{}( unsigned char * ), ?{}( volatile unsigned char * ); +void ?{}( signed int * ), ?{}( volatile signed int * ); +void ?{}( unsigned int * ), ?{}( volatile unsigned int * ); +void ?{}( signed long int * ), ?{}( volatile signed long int * ); +void ?{}( unsigned long int * ), ?{}( volatile unsigned long int * ); +void ?{}( signed long long int * ), ?{}( volatile signed long long int * ); +void ?{}( unsigned long long int * ), ?{}( volatile unsigned long long int * ); +void ?{}( float * ), ?{}( volatile float * ); +void ?{}( double * ), ?{}( volatile double * ); +void ?{}( long double * ), ?{}( volatile long double * ); +void ?{}( float _Complex * ), ?{}( volatile float _Complex * ); +void ?{}( double _Complex * ), ?{}( volatile double _Complex * ); +void ?{}( long double _Complex * ), ?{}( volatile long double _Complex * ); + +// copy ctor +void ?{}( _Bool *, _Bool ), ?{}( volatile _Bool *, _Bool ); +void ?{}( unsigned char *, unsigned char ), ?{}( volatile unsigned char *, unsigned char ); +void ?{}( signed int *, signed int), ?{}( volatile signed int *, signed int ); +void ?{}( unsigned int *, unsigned int), ?{}( volatile unsigned int *, unsigned int ); +void ?{}( signed long int *, signed long int), ?{}( volatile signed long int *, signed long int ); +void ?{}( unsigned long int *, unsigned long int), ?{}( volatile unsigned long int *, unsigned long int ); +void ?{}( signed long long int *, signed long long int), ?{}( volatile signed long long int *, signed long long int ); +void ?{}( unsigned long long int *, unsigned long long int), ?{}( volatile unsigned long long int *, unsigned long long int ); +void ?{}( float *, float), ?{}( volatile float *, float ); +void ?{}( double *, double), ?{}( volatile double *, double ); +void ?{}( long double *, long double), ?{}( volatile long double *, long double ); +void ?{}( float _Complex *, float _Complex), ?{}( volatile float _Complex *, float _Complex ); +void ?{}( double _Complex *, double _Complex), ?{}( volatile double _Complex *, double _Complex ); +void ?{}( long double _Complex *, long double _Complex), ?{}( volatile long double _Complex *, long double _Complex ); + +// dtor +void ^?{}( _Bool * ), ^?{}( volatile _Bool * ); +void ^?{}( signed int * ), ^?{}( volatile signed int * ); +void ^?{}( unsigned int * ), ^?{}( volatile unsigned int * ); +void ^?{}( signed long int * ), ^?{}( volatile signed long int * ); +void ^?{}( unsigned long int * ), ^?{}( volatile unsigned long int * ); +void ^?{}( signed long long int * ), ^?{}( volatile signed long long int * ); +void ^?{}( unsigned long long int * ), ^?{}( volatile unsigned long long int * ); +void ^?{}( float * ), ^?{}( volatile float * ); +void ^?{}( double * ), ^?{}( volatile double * ); +void ^?{}( long double * ), ^?{}( volatile long double * ); +void ^?{}( float _Complex * ), ^?{}( volatile float _Complex * ); +void ^?{}( double _Complex * ), ^?{}( volatile double _Complex * ); +void ^?{}( long double _Complex * ), ^?{}( volatile long double _Complex * ); + +// // default ctor +// forall( dtype DT ) void ?{}( DT ** ); +// forall( dtype DT ) void ?{}( const DT ** ); +// forall( dtype DT ) void ?{}( volatile DT ** ); +// forall( dtype DT ) void ?{}( const volatile DT ** ); + +// // copy ctor +// forall( dtype DT ) void ?{}( DT **, DT* ); +// forall( dtype DT ) void ?{}( const DT **, DT* ); +// forall( dtype DT ) void ?{}( volatile DT **, DT* ); +// forall( dtype DT ) void ?{}( const volatile DT **, DT* ); + +// // dtor +// forall( dtype DT ) void ^?{}( DT ** ); +// forall( dtype DT ) void ^?{}( const DT ** ); +// forall( dtype DT ) void ^?{}( volatile DT ** ); +// forall( dtype DT ) void ^?{}( const volatile DT ** ); + +// copied from assignment section +// copy constructors +forall( ftype FT ) void ?{}( FT **, FT * ); +forall( ftype FT ) void ?{}( FT * volatile *, FT * ); + +forall( dtype DT ) void ?{}( DT * *, DT * ); +forall( dtype DT ) void ?{}( DT * volatile *, DT * ); +forall( dtype DT ) void ?{}( const DT * *, DT * ); +forall( dtype DT ) void ?{}( const DT * volatile *, DT * ); +forall( dtype DT ) void ?{}( const DT * *, const DT * ); +forall( dtype DT ) void ?{}( const DT * volatile *, const DT * ); +forall( dtype DT ) void ?{}( volatile DT * *, DT * ); +forall( dtype DT ) void ?{}( volatile DT * volatile *, DT * ); +forall( dtype DT ) void ?{}( volatile DT * *, volatile DT * ); +forall( dtype DT ) void ?{}( volatile DT * volatile *, volatile DT * ); + +forall( dtype DT ) void ?{}( const volatile DT * *, DT * ); +forall( dtype DT ) void ?{}( const volatile DT * volatile *, DT * ); +forall( dtype DT ) void ?{}( const volatile DT * *, const DT * ); +forall( dtype DT ) void ?{}( const volatile DT * volatile *, const DT * ); +forall( dtype DT ) void ?{}( const volatile DT * *, volatile DT * ); +forall( dtype DT ) void ?{}( const volatile DT * volatile *, volatile DT * ); +forall( dtype DT ) void ?{}( const volatile DT * *, const volatile DT * ); +forall( dtype DT ) void ?{}( const volatile DT * volatile *, const volatile DT * ); + +forall( dtype DT ) void ?{}( DT * *, void * ); +forall( dtype DT ) void ?{}( DT * volatile *, void * ); +forall( dtype DT ) void ?{}( const DT * *, void * ); +forall( dtype DT ) void ?{}( const DT * volatile *, void * ); +forall( dtype DT ) void ?{}( const DT * *, const void * ); +forall( dtype DT ) void ?{}( const DT * volatile *, const void * ); +forall( dtype DT ) void ?{}( volatile DT * *, void * ); +forall( dtype DT ) void ?{}( volatile DT * volatile *, void * ); +forall( dtype DT ) void ?{}( volatile DT * *, volatile void * ); +forall( dtype DT ) void ?{}( volatile DT * volatile *, volatile void * ); + +forall( dtype DT ) void ?{}( const volatile DT * *, void * ); +forall( dtype DT ) void ?{}( const volatile DT * volatile *, void * ); +forall( dtype DT ) void ?{}( const volatile DT * *, const void * ); +forall( dtype DT ) void ?{}( const volatile DT * volatile *, const void * ); +forall( dtype DT ) void ?{}( const volatile DT * *, volatile void * ); +forall( dtype DT ) void ?{}( const volatile DT * volatile *, volatile void * ); +forall( dtype DT ) void ?{}( const volatile DT * *, const volatile void * ); +forall( dtype DT ) void ?{}( const volatile DT * volatile *, const volatile void * ); + +forall( dtype DT ) void ?{}( void * *, DT * ); +forall( dtype DT ) void ?{}( void * volatile *, DT * ); +forall( dtype DT ) void ?{}( const void * *, DT * ); +forall( dtype DT ) void ?{}( const void * volatile *, DT * ); +forall( dtype DT ) void ?{}( const void * *, const DT * ); +forall( dtype DT ) void ?{}( const void * volatile *, const DT * ); +forall( dtype DT ) void ?{}( volatile void * *, DT * ); +forall( dtype DT ) void ?{}( volatile void * volatile *, DT * ); +forall( dtype DT ) void ?{}( volatile void * *, volatile DT * ); +forall( dtype DT ) void ?{}( volatile void * volatile *, volatile DT * ); +forall( dtype DT ) void ?{}( const volatile void * *, DT * ); +forall( dtype DT ) void ?{}( const volatile void * volatile *, DT * ); +forall( dtype DT ) void ?{}( const volatile void * *, const DT * ); +forall( dtype DT ) void ?{}( const volatile void * volatile *, const DT * ); +forall( dtype DT ) void ?{}( const volatile void * *, volatile DT * ); +forall( dtype DT ) void ?{}( const volatile void * volatile *, volatile DT * ); +forall( dtype DT ) void ?{}( const volatile void * *, const volatile DT * ); +forall( dtype DT ) void ?{}( const volatile void * volatile *, const volatile DT * ); + +void ?{}( void * *, void * ); +void ?{}( void * volatile *, void * ); +void ?{}( const void * *, void * ); +void ?{}( const void * volatile *, void * ); +void ?{}( const void * *, const void * ); +void ?{}( const void * volatile *, const void * ); +void ?{}( volatile void * *, void * ); +void ?{}( volatile void * volatile *, void * ); +void ?{}( volatile void * *, volatile void * ); +void ?{}( volatile void * volatile *, volatile void * ); +void ?{}( const volatile void * *, void * ); +void ?{}( const volatile void * volatile *, void * ); +void ?{}( const volatile void * *, const void * ); +void ?{}( const volatile void * volatile *, const void * ); +void ?{}( const volatile void * *, volatile void * ); +void ?{}( const volatile void * volatile *, volatile void * ); +void ?{}( const volatile void * *, const volatile void * ); +void ?{}( const volatile void * volatile *, const volatile void * ); + +//forall( dtype DT ) void ?{}( DT * *, forall( dtype DT2 ) const DT2 * ); +//forall( dtype DT ) void ?{}( DT * volatile *, forall( dtype DT2 ) const DT2 * ); +forall( dtype DT ) void ?{}( const DT * *, forall( dtype DT2 ) const DT2 * ); +forall( dtype DT ) void ?{}( const DT * volatile *, forall( dtype DT2 ) const DT2 * ); +//forall( dtype DT ) void ?{}( volatile DT * *, forall( dtype DT2 ) const DT2 * ); +//forall( dtype DT ) void ?{}( volatile DT * volatile *, forall( dtype DT2 ) const DT2 * ); +forall( dtype DT ) void ?{}( const volatile DT * *, forall( dtype DT2 ) const DT2 * ); +forall( dtype DT ) void ?{}( const volatile DT * volatile *, forall( dtype DT2 ) const DT2 * ); + +forall( ftype FT ) void ?{}( FT * *, forall( ftype FT2 ) FT2 * ); +forall( ftype FT ) void ?{}( FT * volatile *, forall( ftype FT2 ) FT2 * ); + +// default ctors +forall( ftype FT ) void ?{}( FT * * ); +forall( ftype FT ) void ?{}( FT * volatile * ); + +forall( dtype DT ) void ?{}( DT * *); +forall( dtype DT ) void ?{}( DT * volatile *); +forall( dtype DT ) void ?{}( const DT * *); +forall( dtype DT ) void ?{}( const DT * volatile *); +forall( dtype DT ) void ?{}( volatile DT * *); +forall( dtype DT ) void ?{}( volatile DT * volatile *); +forall( dtype DT ) void ?{}( const volatile DT * *); +forall( dtype DT ) void ?{}( const volatile DT * volatile *); + +void ?{}( void * *); +void ?{}( void * volatile *); +void ?{}( const void * *); +void ?{}( const void * volatile *); +void ?{}( volatile void * *); +void ?{}( volatile void * volatile *); +void ?{}( const volatile void * *); +void ?{}( const volatile void * volatile *); + +// dtors +forall( ftype FT ) void ^?{}( FT * * ); +forall( ftype FT ) void ^?{}( FT * volatile * ); + +forall( dtype DT ) void ^?{}( DT * *); +forall( dtype DT ) void ^?{}( DT * volatile *); +forall( dtype DT ) void ^?{}( const DT * *); +forall( dtype DT ) void ^?{}( const DT * volatile *); +forall( dtype DT ) void ^?{}( volatile DT * *); +forall( dtype DT ) void ^?{}( volatile DT * volatile *); +forall( dtype DT ) void ^?{}( const volatile DT * *); +forall( dtype DT ) void ^?{}( const volatile DT * volatile *); + +void ^?{}( void * *); +void ^?{}( void * volatile *); +void ^?{}( const void * *); +void ^?{}( const void * volatile *); +void ^?{}( volatile void * *); +void ^?{}( volatile void * volatile *); +void ^?{}( const volatile void * *); +void ^?{}( const volatile void * volatile *); Index: src/main.cc =================================================================== --- src/main.cc (revision 71f4e4f59e25d1ae31af19227f4d2a8a9365bac7) +++ src/main.cc (revision f1e012b7aa1aaea6aa2dde9bcb3b0e83dcf13824) @@ -10,6 +10,6 @@ // Created On : Fri May 15 23:12:02 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Wed Jan 13 16:47:25 2016 -// Update Count : 181 +// Last Modified On : Tue Jan 19 13:16:23 2016 +// Update Count : 185 // @@ -247,5 +247,5 @@ OPTPRINT( "fixNames" ) CodeGen::fixNames( translationUnit ); - OPTPRINT( "tweak" ) + OPTPRINT( "tweakInit" ) InitTweak::tweak( translationUnit ); @@ -266,4 +266,5 @@ } + OPTPRINT( "fixInit" ) // fix ObjectDecl - replaces ConstructorInit nodes InitTweak::fix( translationUnit );