Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/CodeGen/CodeGenerator.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -192,4 +192,5 @@ genCommaList( aggDecl->get_parameters().begin(), aggDecl->get_parameters().end() ); output << ")" << endl; + output << indent; } @@ -332,6 +333,10 @@ void CodeGenerator::visit( __attribute__((unused)) ConstructorInit * init ){ assertf( ! genC, "ConstructorInit nodes should not reach code generation." ); - // xxx - generate something reasonable for constructor/destructor pairs - output << ""; + // pseudo-output for constructor/destructor pairs + output << "{" << std::endl << ++indent << "ctor: "; + maybeAccept( init->get_ctor(), *this ); + output << ", " << std::endl << indent << "dtor: "; + maybeAccept( init->get_dtor(), *this ); + output << std::endl << --indent << "}"; } @@ -347,35 +352,4 @@ if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( varExpr->get_var()->get_name(), opInfo ) ) { std::list< Expression* >::iterator arg = applicationExpr->get_args().begin(); - switch ( opInfo.type ) { - case OT_PREFIXASSIGN: - case OT_POSTFIXASSIGN: - case OT_INFIXASSIGN: - case OT_CTOR: - case OT_DTOR: - { - assert( arg != applicationExpr->get_args().end() ); - if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( *arg ) ) { - // remove & from first assignment/ctor argument - *arg = addrExpr->get_arg(); - } else { - // no address-of operator, so must be a pointer - add dereference - // NOTE: if the assertion starts to trigger, check that the application expr isn't being shared. - // Since its arguments are modified here, this assertion most commonly triggers when the application - // is visited multiple times. - UntypedExpr * newExpr = new UntypedExpr( new NameExpr( "*?" ) ); - newExpr->get_args().push_back( *arg ); - Type * type = InitTweak::getPointerBase( (*arg)->get_result() ); - assertf( type, "First argument to a derefence must be a pointer. Ensure that expressions are not being shared." ); - newExpr->set_result( type->clone() ); - *arg = newExpr; - } // if - break; - } - - default: - // do nothing - ; - } // switch - switch ( opInfo.type ) { case OT_INDEX: @@ -584,12 +558,11 @@ if ( castExpr->get_result()->isVoid() ) { output << "(void)" ; - } else if ( ! castExpr->get_result()->get_lvalue() ) { - // at least one result type of cast, but not an lvalue + } else { + // at least one result type of cast. + // Note: previously, lvalue casts were skipped. Since it's now impossible for the user to write + // an lvalue cast, this has been taken out. output << "("; output << genType( castExpr->get_result(), "", pretty, genC ); output << ")"; - } else { - // otherwise, the cast is to an lvalue type, so the cast should be dropped, since the result of a cast is - // never an lvalue in C } // if castExpr->get_arg()->accept( *this ); @@ -706,8 +679,17 @@ extension( commaExpr ); output << "("; + if ( genC ) { + // arg1 of a CommaExpr is never used, so it can be safely cast to void to reduce gcc warnings. + commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) ); + } commaExpr->get_arg1()->accept( *this ); output << " , "; commaExpr->get_arg2()->accept( *this ); output << ")"; + } + + void CodeGenerator::visit( TupleAssignExpr * tupleExpr ) { + assertf( ! genC, "TupleAssignExpr should not reach code generation." ); + tupleExpr->stmtExpr->accept( *this ); } @@ -759,4 +741,11 @@ output << "(" << genType( compLitExpr->get_result(), "", pretty, genC ) << ")"; compLitExpr->get_initializer()->accept( *this ); + } + + void CodeGenerator::visit( UniqueExpr * unqExpr ) { + assertf( ! genC, "Unique expressions should not reach code generation." ); + output << "unq<" << unqExpr->get_id() << ">{ "; + unqExpr->get_expr()->accept( *this ); + output << " }"; } @@ -770,5 +759,5 @@ for ( Statement * stmt : stmts ) { updateLocation( stmt ); - output << printLabels( stmt->get_labels() ); + output << printLabels( stmt->get_labels() ); if ( i+1 == numStmts ) { // last statement in a statement expression needs to be handled specially - @@ -815,10 +804,9 @@ void CodeGenerator::visit( ExprStmt * exprStmt ) { assert( exprStmt ); - Expression * expr = exprStmt->get_expr(); if ( genC ) { // cast the top-level expression to void to reduce gcc warnings. - expr = new CastExpr( expr ); - } - expr->accept( *this ); + exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) ); + } + exprStmt->get_expr()->accept( *this ); output << ";"; } Index: src/CodeGen/CodeGenerator.h =================================================================== --- src/CodeGen/CodeGenerator.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/CodeGen/CodeGenerator.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -74,4 +74,6 @@ virtual void visit( CommaExpr *commaExpr ); virtual void visit( CompoundLiteralExpr *compLitExpr ); + virtual void visit( UniqueExpr * ); + virtual void visit( TupleAssignExpr * tupleExpr ); virtual void visit( UntypedTupleExpr *tupleExpr ); virtual void visit( TupleExpr *tupleExpr ); Index: src/CodeGen/GenType.cc =================================================================== --- src/CodeGen/GenType.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/CodeGen/GenType.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -37,4 +37,5 @@ virtual void visit( PointerType *pointerType ); virtual void visit( ArrayType *arrayType ); + virtual void visit( ReferenceType *refType ); virtual void visit( StructInstType *structInst ); virtual void visit( UnionInstType *unionInst ); @@ -145,4 +146,12 @@ void GenType::visit( ArrayType *arrayType ) { genArray( arrayType->get_qualifiers(), arrayType->get_base(), arrayType->get_dimension(), arrayType->get_isVarLen(), arrayType->get_isStatic() ); + } + + void GenType::visit( ReferenceType *refType ) { + assert( refType->get_base() != 0); + assertf( ! genC, "Reference types should not reach code generation." ); + handleQualifiers( refType ); + typeString = "&" + typeString; + refType->get_base()->accept( *this ); } @@ -278,4 +287,8 @@ typeString = "_Atomic " + typeString; } // if + if ( type->get_lvalue() && ! genC ) { + // when not generating C code, print lvalue for debugging. + typeString = "lvalue " + typeString; + } } } // namespace CodeGen Index: src/CodeGen/OperatorTable.cc =================================================================== --- src/CodeGen/OperatorTable.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/CodeGen/OperatorTable.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -14,6 +14,7 @@ // -#include // for map, _Rb_tree_const_iterator, map<>::const_iterator -#include // for pair +#include // for any_of +#include // for map, _Rb_tree_const_iterator, map<>::const_iterator +#include // for pair #include "OperatorTable.h" @@ -93,4 +94,39 @@ } // if } + + /// determines if a given function name is one of the operator types between [begin, end) + template + bool isOperatorType( const std::string & funcName, Iterator begin, Iterator end ) { + OperatorInfo info; + if ( operatorLookup( funcName, info ) ) { + return std::find( begin, end, info.type ) != end; + } + return false; + } + + bool isConstructor( const std::string & funcName ) { + static OperatorType types[] = { OT_CTOR }; + return isOperatorType( funcName, std::begin(types), std::end(types) ); + } + + bool isDestructor( const std::string & funcName ) { + static OperatorType types[] = { OT_DTOR }; + return isOperatorType( funcName, std::begin(types), std::end(types) ); + } + + bool isAssignment( const std::string & funcName ) { + static OperatorType types[] = { OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN }; + return isOperatorType( funcName, std::begin(types), std::end(types) ); + } + + bool isCtorDtor( const std::string & funcName ) { + static OperatorType types[] = { OT_CTOR, OT_DTOR }; + return isOperatorType( funcName, std::begin(types), std::end(types) ); + } + + bool isCtorDtorAssign( const std::string & funcName ) { + static OperatorType types[] = { OT_CTOR, OT_DTOR, OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN }; + return isOperatorType( funcName, std::begin(types), std::end(types) ); + } } // namespace CodeGen Index: src/CodeGen/OperatorTable.h =================================================================== --- src/CodeGen/OperatorTable.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/CodeGen/OperatorTable.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// OperatorTable.h -- +// OperatorTable.h -- // // Author : Richard C. Bilson @@ -42,4 +42,10 @@ bool operatorLookup( std::string funcName, OperatorInfo &info ); + + bool isConstructor( const std::string & ); + bool isDestructor( const std::string & ); + bool isAssignment( const std::string & ); + bool isCtorDtor( const std::string & ); + bool isCtorDtorAssign( const std::string & ); } // namespace CodeGen Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Common/PassVisitor.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -116,4 +116,5 @@ virtual void visit( PointerType *pointerType ) override final; virtual void visit( ArrayType *arrayType ) override final; + virtual void visit( ReferenceType *referenceType ) override final; virtual void visit( FunctionType *functionType ) override final; virtual void visit( StructInstType *aggregateUseType ) override final; @@ -202,4 +203,5 @@ virtual Type* mutate( PointerType *pointerType ) override final; virtual Type* mutate( ArrayType *arrayType ) override final; + virtual Type* mutate( ReferenceType *referenceType ) override final; virtual Type* mutate( FunctionType *functionType ) override final; virtual Type* mutate( StructInstType *aggregateUseType ) override final; Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Common/PassVisitor.impl.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -792,4 +792,9 @@ template< typename pass_type > +void PassVisitor< pass_type >::visit( ReferenceType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > void PassVisitor< pass_type >::visit( FunctionType * node ) { VISIT_BODY( node ); @@ -1129,4 +1134,9 @@ template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( ReferenceType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > Type * PassVisitor< pass_type >::mutate( FunctionType * node ) { MUTATE_BODY( Type, node ); Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Common/utility.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -310,6 +310,6 @@ template< typename T1, typename T2 > struct group_iterate_t { - group_iterate_t( const T1 & v1, const T2 & v2 ) : args(v1, v2) { - assertf(v1.size() == v2.size(), "group iteration requires containers of the same size."); + group_iterate_t( bool skipBoundsCheck, const T1 & v1, const T2 & v2 ) : args(v1, v2) { + assertf(skipBoundsCheck || v1.size() == v2.size(), "group iteration requires containers of the same size: <%lu, %lu>.", v1.size(), v2.size()); }; @@ -336,7 +336,14 @@ }; +/// performs bounds check to ensure that all arguments are of the same length. template< typename... Args > group_iterate_t group_iterate( Args &&... args ) { - return group_iterate_t(std::forward( args )...); + return group_iterate_t(false, std::forward( args )...); +} + +/// does not perform a bounds check - requires user to ensure that iteration terminates when appropriate. +template< typename... Args > +group_iterate_t unsafe_group_iterate( Args &&... args ) { + return group_iterate_t(true, std::forward( args )...); } Index: src/Concurrency/Keywords.cc =================================================================== --- src/Concurrency/Keywords.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Concurrency/Keywords.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -21,5 +21,6 @@ #include "Common/SemanticError.h" // for SemanticError #include "Common/utility.h" // for deleteAll, map_range -#include "InitTweak/InitTweak.h" // for isConstructor +#include "CodeGen/OperatorTable.h" // for isConstructor +#include "InitTweak/InitTweak.h" // for getPointerBase #include "Parser/LinkageSpec.h" // for Cforall #include "SymTab/AddVisit.h" // for acceptAndAdd @@ -289,5 +290,5 @@ LinkageSpec::Cforall, nullptr, - new PointerType( + new ReferenceType( noQualifiers, new StructInstType( @@ -445,10 +446,11 @@ //Makes sure it's not a copy - PointerType* pty = dynamic_cast< PointerType * >( ty ); - if( ! pty ) throw SemanticError( "Mutex argument must be of pointer/reference type ", arg ); + ReferenceType* rty = dynamic_cast< ReferenceType * >( ty ); + if( ! rty ) throw SemanticError( "Mutex argument must be of reference type ", arg ); //Make sure the we are pointing directly to a type - Type* base = pty->get_base(); - if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg ); + Type* base = rty->get_base(); + if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg ); + if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg ); //Make sure that typed isn't mutex @@ -520,10 +522,8 @@ Visitor::visit(decl); - if( ! InitTweak::isConstructor(decl->get_name()) ) return; + if( ! CodeGen::isConstructor(decl->get_name()) ) return; DeclarationWithType * param = decl->get_functionType()->get_parameters().front(); - auto ptr = dynamic_cast< PointerType * >( param->get_type() ); - // if( ptr ) std::cerr << "FRED1" << std::endl; - auto type = dynamic_cast< StructInstType * >( ptr->get_base() ); + auto type = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) ); // if( type ) std::cerr << "FRED2" << std::endl; if( type && type->get_baseStruct()->is_thread() ) { Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/GenPoly/Box.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -25,4 +25,6 @@ #include "Box.h" + +#include "CodeGen/OperatorTable.h" #include "Common/ScopedMap.h" // for ScopedMap, ScopedMap<>::iter... #include "Common/SemanticError.h" // for SemanticError @@ -564,5 +566,5 @@ // To compound the issue, the right side can be *x, etc. because of lvalue-returning functions if ( UntypedExpr * assign = dynamic_cast< UntypedExpr * >( commaExpr->get_arg1() ) ) { - if ( InitTweak::isAssignment( InitTweak::getFunctionName( assign ) ) ) { + if ( CodeGen::isAssignment( InitTweak::getFunctionName( assign ) ) ) { assert( assign->get_args().size() == 2 ); if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( assign->get_args().back() ) ) { @@ -604,5 +606,5 @@ } } else { - throw SemanticError( "Cannot pass non-struct type for generic struct" ); + throw SemanticError( "Cannot pass non-struct type for generic struct: ", argBaseType ); } } @@ -1019,4 +1021,5 @@ } // if if ( baseType1 || baseType2 ) { + delete ret->get_result(); ret->set_result( appExpr->get_result()->clone() ); if ( appExpr->get_env() ) { @@ -1032,5 +1035,7 @@ assert( ! appExpr->get_args().empty() ); if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) { + // remove dereference from polymorphic types since they are boxed. Expression *ret = appExpr->get_args().front(); + // fix expr type to remove pointer delete ret->get_result(); ret->set_result( appExpr->get_result()->clone() ); @@ -1122,6 +1127,6 @@ assert( appExpr->get_function()->has_result() ); - PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() ); - FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() ); + FunctionType * function = getFunctionType( appExpr->get_function()->get_result() ); + assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->get_function()->get_result() ).c_str() ); if ( Expression *newExpr = handleIntrinsics( appExpr ) ) { @@ -1200,6 +1205,6 @@ if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) { assert( appExpr->get_function()->has_result() ); - PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() ); - FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() ); + FunctionType *function = getFunctionType( appExpr->get_function()->get_result() ); + assert( function ); needs = needsAdapter( function, scopeTyVars ); } // if @@ -1210,6 +1215,7 @@ // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward // out of the if condition. + addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) ); + // ... but must happen after mutate, since argument might change (e.g. intrinsic *?, ?[?]) - re-evaluate above comment bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env ); - addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) ); if ( polytype || needs ) { Expression *ret = addrExpr->get_arg(); @@ -1278,5 +1284,6 @@ if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) { std::string adapterName = makeAdapterName( mangleName ); - paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) ); + // adapter may not be used in body, pass along with unused attribute. + paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) ); adaptersDone.insert( adaptersDone.begin(), mangleName ); } @@ -1384,5 +1391,7 @@ std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin(); std::list< DeclarationWithType *> inferredParams; - ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 ); + // size/align/offset parameters may not be used in body, pass along with unused attribute. + ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, + { new Attribute( "unused" ) } ); ObjectDecl newPtr( "", Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 ); @@ -1407,4 +1416,6 @@ for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) { // *assert = (*assert)->acceptMutator( *this ); + // assertion parameters may not be used in body, pass along with unused attribute. + (*assert)->get_attributes().push_back( new Attribute( "unused" ) ); inferredParams.push_back( *assert ); } Index: src/GenPoly/InstantiateGeneric.cc =================================================================== --- src/GenPoly/InstantiateGeneric.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/GenPoly/InstantiateGeneric.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -162,4 +162,6 @@ /// Should not make use of type environment to replace types of function parameter and return values. bool inFunctionType = false; + /// Index of current member, used to recreate MemberExprs with the member from an instantiation + int memberIndex = -1; GenericInstantiator() : instantiations(), dtypeStatics(), typeNamer("_conc_") {} @@ -167,5 +169,9 @@ Type* postmutate( UnionInstType *inst ); - void premutate( __attribute__((unused)) FunctionType * ftype ) { + // fix MemberExprs to use the member from the instantiation + void premutate( MemberExpr * memberExpr ); + Expression * postmutate( MemberExpr * memberExpr ); + + void premutate( FunctionType * ) { GuardValue( inFunctionType ); inFunctionType = true; @@ -414,4 +420,52 @@ } + namespace { + bool isGenericType( Type * t ) { + if ( StructInstType * inst = dynamic_cast< StructInstType * >( t ) ) { + return ! inst->parameters.empty(); + } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( t ) ) { + return ! inst->parameters.empty(); + } + return false; + } + + AggregateDecl * getAggr( Type * t ) { + if ( StructInstType * inst = dynamic_cast< StructInstType * >( t ) ) { + return inst->baseStruct; + } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( t ) ) { + return inst->baseUnion; + } + assertf( false, "Non-aggregate type: %s", toString( t ).c_str() ); + } + } + + void GenericInstantiator::premutate( MemberExpr * memberExpr ) { + GuardValue( memberIndex ); + memberIndex = -1; + if ( isGenericType( memberExpr->aggregate->result ) ) { + // find the location of the member + AggregateDecl * aggr = getAggr( memberExpr->aggregate->result ); + std::list< Declaration * > & members = aggr->members; + memberIndex = std::distance( members.begin(), std::find( members.begin(), members.end(), memberExpr->member ) ); + assertf( memberIndex < (int)members.size(), "Could not find member %s in generic type %s", toString( memberExpr->member ).c_str(), toString( memberExpr->aggregate ).c_str() ); + } + } + + Expression * GenericInstantiator::postmutate( MemberExpr * memberExpr ) { + if ( memberIndex != -1 ) { + // using the location from the generic type, find the member in the instantiation and rebuild the member expression + AggregateDecl * aggr = getAggr( memberExpr->aggregate->result ); + assertf( memberIndex < (int)aggr->members.size(), "Instantiation somehow has fewer members than the generic type." ); + Declaration * member = *std::next( aggr->members.begin(), memberIndex ); + assertf( member->name == memberExpr->member->name, "Instantiation has different member order than the generic type. %s / %s", toString( member ).c_str(), toString( memberExpr->member ).c_str() ); + DeclarationWithType * field = safe_dynamic_cast< DeclarationWithType * >( member ); + MemberExpr * ret = new MemberExpr( field, memberExpr->aggregate->clone() ); + std::swap( ret->env, memberExpr->env ); + delete memberExpr; + return ret; + } + return memberExpr; + } + void GenericInstantiator::beginScope() { instantiations.beginScope(); Index: src/GenPoly/Lvalue.cc =================================================================== --- src/GenPoly/Lvalue.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/GenPoly/Lvalue.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -17,10 +17,14 @@ #include // for string +#include "Common/PassVisitor.h" #include "Common/SemanticError.h" // for SemanticError #include "GenPoly.h" // for isPolyType #include "Lvalue.h" + #include "Parser/LinkageSpec.h" // for Spec, isBuiltin, Intrinsic #include "ResolvExpr/TypeEnvironment.h" // for AssertionSet, OpenVarSet #include "ResolvExpr/Unify.h" // for unify +#include "ResolvExpr/typeops.h" +#include "SymTab/Autogen.h" #include "SymTab/Indexer.h" // for Indexer #include "SynTree/Declaration.h" // for Declaration, FunctionDecl @@ -31,23 +35,48 @@ #include "SynTree/Visitor.h" // for Visitor, acceptAll +#if 0 +#define PRINT(x) x +#else +#define PRINT(x) +#endif + namespace GenPoly { namespace { - /// Replace uses of lvalue returns with appropriate pointers - class Pass1 : public Mutator { - public: - Pass1(); - - virtual Expression *mutate( ApplicationExpr *appExpr ); - virtual Statement *mutate( ReturnStmt *appExpr ); - virtual DeclarationWithType *mutate( FunctionDecl *funDecl ); - private: - DeclarationWithType* retval; - }; - - /// Replace declarations of lvalue returns with appropriate pointers - class Pass2 : public Visitor { - public: - virtual void visit( FunctionType *funType ); - private: + // TODO: fold this into the general createDeref function?? + Expression * mkDeref( Expression * arg ) { + if ( SymTab::dereferenceOperator ) { + VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator ); + deref->set_result( new PointerType( Type::Qualifiers(), deref->get_result() ) ); + Type * base = InitTweak::getPointerBase( arg->get_result() ); + assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->get_result() ).c_str() ); + ApplicationExpr * ret = new ApplicationExpr( deref, { arg } ); + delete ret->get_result(); + ret->set_result( base->clone() ); + ret->get_result()->set_lvalue( true ); + return ret; + } else { + return UntypedExpr::createDeref( arg ); + } + } + + struct ReferenceConversions final { + Expression * postmutate( CastExpr * castExpr ); + Expression * postmutate( AddressExpr * addrExpr ); + }; + + /// Intrinsic functions that take reference parameters don't REALLY take reference parameters -- their reference arguments must always be implicitly dereferenced. + struct FixIntrinsicArgs final { + Expression * postmutate( ApplicationExpr * appExpr ); + }; + + struct FixIntrinsicResult final : public WithGuards { + Expression * postmutate( ApplicationExpr * appExpr ); + void premutate( FunctionDecl * funcDecl ); + bool inIntrinsic = false; + }; + + /// Replace reference types with pointer types + struct ReferenceTypeElimination final { + Type * postmutate( ReferenceType * refType ); }; @@ -55,117 +84,325 @@ /// https://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Lvalues.html#Lvalues /// Replaces &(a,b) with (a, &b), &(a ? b : c) with (a ? &b : &c) - class GeneralizedLvalue : public Mutator { - typedef Mutator Parent; - - virtual Expression * mutate( MemberExpr * memExpr ); - virtual Expression * mutate( AddressExpr * addressExpr ); + struct GeneralizedLvalue final : public WithVisitorRef { + Expression * postmutate( AddressExpr * addressExpr ); + Expression * postmutate( MemberExpr * memExpr ); template Expression * applyTransformation( Expression * expr, Expression * arg, Func mkExpr ); }; + + /// Removes redundant &*/*& pattern that this pass can generate + struct CollapseAddrDeref final { + Expression * postmutate( AddressExpr * addressExpr ); + Expression * postmutate( ApplicationExpr * appExpr ); + }; + + struct AddrRef final : public WithGuards { + void premutate( AddressExpr * addrExpr ); + Expression * postmutate( AddressExpr * addrExpr ); + void premutate( Expression * expr ); + + bool first = true; + bool current = false; + int refDepth = 0; + }; } // namespace + static bool referencesEliminated = false; + // used by UntypedExpr::createDeref to determine whether result type of dereference should be ReferenceType or value type. + bool referencesPermissable() { + return ! referencesEliminated; + } + void convertLvalue( std::list< Declaration* >& translationUnit ) { - Pass1 p1; - Pass2 p2; - GeneralizedLvalue genLval; - mutateAll( translationUnit, p1 ); - acceptAll( translationUnit, p2 ); + PassVisitor refCvt; + PassVisitor elim; + PassVisitor genLval; + PassVisitor fixer; + PassVisitor collapser; + PassVisitor addrRef; + PassVisitor intrinsicResults; + mutateAll( translationUnit, intrinsicResults ); + mutateAll( translationUnit, addrRef ); + mutateAll( translationUnit, refCvt ); + mutateAll( translationUnit, fixer ); + mutateAll( translationUnit, collapser ); mutateAll( translationUnit, genLval ); + mutateAll( translationUnit, elim ); // last because other passes need reference types to work + + // from this point forward, no other pass should create reference types. + referencesEliminated = true; } Expression * generalizedLvalue( Expression * expr ) { - GeneralizedLvalue genLval; + PassVisitor genLval; return expr->acceptMutator( genLval ); } namespace { - Type* isLvalueRet( FunctionType *function ) { - if ( function->get_returnVals().empty() ) return 0; - Type *ty = function->get_returnVals().front()->get_type(); - return ty->get_lvalue() ? ty : 0; - } - - bool isIntrinsicApp( ApplicationExpr *appExpr ) { - if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( appExpr->get_function() ) ) { - return varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic; - } else { - return false; - } // if - } - - Pass1::Pass1() { - } - - DeclarationWithType * Pass1::mutate( FunctionDecl *funcDecl ) { - if ( funcDecl->get_statements() ) { - DeclarationWithType* oldRetval = retval; - retval = 0; - if ( ! LinkageSpec::isBuiltin( funcDecl->get_linkage() ) && isLvalueRet( funcDecl->get_functionType() ) ) { - retval = funcDecl->get_functionType()->get_returnVals().front(); - } - // fix expressions and return statements in this function - funcDecl->set_statements( funcDecl->get_statements()->acceptMutator( *this ) ); - retval = oldRetval; - } // if - return funcDecl; - } - - Expression * Pass1::mutate( ApplicationExpr *appExpr ) { - appExpr->get_function()->acceptMutator( *this ); - mutateAll( appExpr->get_args(), *this ); - - PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() ); - FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() ); - - Type *funType = isLvalueRet( function ); - if ( funType && ! isIntrinsicApp( appExpr ) ) { - Expression *expr = appExpr; - Type *appType = appExpr->get_result(); - if ( isPolyType( funType ) && ! isPolyType( appType ) ) { - // make sure cast for polymorphic type is inside dereference - expr = new CastExpr( appExpr, new PointerType( Type::Qualifiers(), appType->clone() ) ); - } - UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) ); - deref->set_result( appType->clone() ); - appExpr->set_result( new PointerType( Type::Qualifiers(), appType ) ); - deref->get_args().push_back( expr ); - return deref; - } else { - return appExpr; - } // if - } - - Statement * Pass1::mutate(ReturnStmt *retStmt) { - if ( retval && retStmt->get_expr() ) { - if ( retStmt->get_expr()->get_result()->get_lvalue() ) { - // ***** Code Removal ***** because casts may be stripped already - - // strip casts because not allowed to take address of cast - // while ( CastExpr *castExpr = dynamic_cast< CastExpr* >( retStmt->get_expr() ) ) { - // retStmt->set_expr( castExpr->get_arg() ); - // retStmt->get_expr()->set_env( castExpr->get_env() ); - // castExpr->set_env( 0 ); - // castExpr->set_arg( 0 ); - // delete castExpr; - // } // while - retStmt->set_expr( new AddressExpr( retStmt->get_expr()->acceptMutator( *this ) ) ); + // true for intrinsic function calls that return a reference + bool isIntrinsicReference( Expression * expr ) { + if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) { + std::string fname = InitTweak::getFunctionName( untyped ); + // known intrinsic-reference prelude functions + return fname == "*?" || fname == "?[?]"; + } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) { + if ( DeclarationWithType * func = InitTweak::getFunction( appExpr ) ) { + // use type of return variable rather than expr result type, since it may have been changed to a pointer type + FunctionType * ftype = GenPoly::getFunctionType( func->get_type() ); + Type * ret = ftype->get_returnVals().empty() ? nullptr : ftype->get_returnVals().front()->get_type(); + return func->get_linkage() == LinkageSpec::Intrinsic && dynamic_cast( ret ); + } + } + return false; + } + + Expression * FixIntrinsicResult::postmutate( ApplicationExpr * appExpr ) { + if ( isIntrinsicReference( appExpr ) ) { + // eliminate reference types from intrinsic applications - now they return lvalues + Type * result = appExpr->get_result(); + appExpr->set_result( result->stripReferences()->clone() ); + appExpr->get_result()->set_lvalue( true ); + if ( ! inIntrinsic ) { + // when not in an intrinsic function, add a cast to + // don't add cast when in an intrinsic function, since they already have the cast + Expression * ret = new CastExpr( appExpr, result ); + ret->set_env( appExpr->get_env() ); + appExpr->set_env( nullptr ); + return ret; + } + delete result; + } + return appExpr; + } + + void FixIntrinsicResult::premutate( FunctionDecl * funcDecl ) { + GuardValue( inIntrinsic ); + inIntrinsic = funcDecl->linkage == LinkageSpec::Intrinsic; + } + + Expression * FixIntrinsicArgs::postmutate( ApplicationExpr * appExpr ) { + // intrinsic functions don't really take reference-typed parameters, so they require an implicit dereference on their arguments. + if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) { + FunctionType * ftype = GenPoly::getFunctionType( function->get_type() ); + assertf( ftype, "Function declaration does not have function type." ); + // can be of differing lengths only when function is variadic + assertf( ftype->get_parameters().size() == appExpr->get_args().size() || ftype->get_isVarArgs(), "ApplicationExpr args do not match formal parameter type." ); + + + unsigned int i = 0; + const unsigned int end = ftype->get_parameters().size(); + for ( auto p : unsafe_group_iterate( appExpr->get_args(), ftype->get_parameters() ) ) { + if (i == end) break; + Expression *& arg = std::get<0>( p ); + Type * formal = std::get<1>( p )->get_type(); + PRINT( + std::cerr << "pair<0>: " << arg << std::endl; + std::cerr << "pair<1>: " << formal << std::endl; + ) + if ( dynamic_cast( formal ) ) { + if ( isIntrinsicReference( arg ) ) { // do not combine conditions, because that changes the meaning of the else if + if ( function->get_linkage() != LinkageSpec::Intrinsic ) { // intrinsic functions that turn pointers into references + // if argument is dereference or array subscript, the result isn't REALLY a reference, so it's not necessary to fix the argument + PRINT( + std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl; + ) + arg = new AddressExpr( arg ); + } + } else if ( function->get_linkage() == LinkageSpec::Intrinsic ) { + // std::cerr << "===adding deref to arg" << std::endl; + // if the parameter is a reference, add a dereference to the reference-typed argument. + Type * baseType = InitTweak::getPointerBase( arg->get_result() ); + assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->get_result() ).c_str() ); + PointerType * ptrType = new PointerType( Type::Qualifiers(), baseType->clone() ); + delete arg->get_result(); + arg->set_result( ptrType ); + arg = mkDeref( arg ); + } + } + ++i; + } + } + return appExpr; + } + + // idea: &&&E: get outer &, inner & + // at inner &, record depth D of reference type + // at outer &, add D derefs. + void AddrRef::premutate( Expression * ) { + GuardValue( current ); + GuardValue( first ); + current = false; + first = true; + } + + void AddrRef::premutate( AddressExpr * ) { + GuardValue( current ); + GuardValue( first ); + current = first; + first = false; + if ( current ) { + GuardValue( refDepth ); + refDepth = 0; + } + } + + Expression * AddrRef::postmutate( AddressExpr * addrExpr ) { + if ( refDepth == 0 ) { + if ( ! isIntrinsicReference( addrExpr->get_arg() ) ) { + // try to avoid ?[?] + refDepth = addrExpr->get_arg()->get_result()->referenceDepth(); + } + } + if ( current ) { + Expression * ret = addrExpr; + while ( refDepth ) { + ret = mkDeref( ret ); + refDepth--; + } + return ret; + } + return addrExpr; + } + + Expression * ReferenceConversions::postmutate( AddressExpr * addrExpr ) { + // Inner expression may have been lvalue to reference conversion, which becomes an address expression. + // In this case, remove the outer address expression and return the argument. + // TODO: It's possible that this might catch too much and require a more sophisticated check. + return addrExpr; + } + + Expression * ReferenceConversions::postmutate( CastExpr * castExpr ) { + // xxx - is it possible to convert directly between reference types with a different base? E.g., + // int x; + // (double&)x; + // At the moment, I am working off of the assumption that this is illegal, thus the cast becomes redundant + // after this pass, so trash the cast altogether. If that changes, care must be taken to insert the correct + // pointer casts in the right places. + + // conversion to reference type + if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_result() ) ) { + (void)refType; + if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) { + // nothing to do if casting from reference to reference. + (void)otherRef; + PRINT( std::cerr << "convert reference to reference -- nop" << std::endl; ) + if ( isIntrinsicReference( castExpr->get_arg() ) ) { + Expression * callExpr = castExpr->get_arg(); + PRINT( + std::cerr << "but arg is deref -- &" << std::endl; + std::cerr << callExpr << std::endl; + ) + callExpr = new AddressExpr( callExpr ); // this doesn't work properly for multiple casts + delete callExpr->get_result(); + callExpr->set_result( refType->clone() ); + // move environment out to new top-level + callExpr->set_env( castExpr->get_env() ); + castExpr->set_arg( nullptr ); + castExpr->set_env( nullptr ); + delete castExpr; + return callExpr; + } + int depth1 = refType->referenceDepth(); + int depth2 = otherRef->referenceDepth(); + int diff = depth1-depth2; + if ( diff == 0 ) { + assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() ); + PRINT( std::cerr << castExpr << std::endl; ) + return castExpr; + } else if ( diff < 0 ) { + Expression * ret = castExpr->get_arg(); + for ( int i = 0; i < diff; ++i ) { + ret = mkDeref( ret ); + } + ret->set_env( castExpr->get_env() ); + delete ret->get_result(); + ret->set_result( castExpr->get_result() ); + castExpr->set_env( nullptr ); + castExpr->set_arg( nullptr ); + castExpr->set_result( nullptr ); + delete castExpr; + return ret; + } else if ( diff > 0 ) { + Expression * ret = castExpr->get_arg(); + for ( int i = 0; i < diff; ++i ) { + ret = new AddressExpr( ret ); + } + ret->set_env( castExpr->get_env() ); + delete ret->get_result(); + ret->set_result( castExpr->get_result() ); + castExpr->set_env( nullptr ); + castExpr->set_arg( nullptr ); + castExpr->set_result( nullptr ); + delete castExpr; + return ret; + } + + assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() ); + PRINT( std::cerr << castExpr << std::endl; ) + return castExpr; + } else if ( castExpr->get_arg()->get_result()->get_lvalue() ) { + // conversion from lvalue to reference + // xxx - keep cast, but turn into pointer cast?? + // xxx - memory + PRINT( + std::cerr << "convert lvalue to reference -- &" << std::endl; + std::cerr << castExpr->get_arg() << std::endl; + ) + AddressExpr * ret = new AddressExpr( castExpr->get_arg() ); + if ( refType->get_base()->get_qualifiers() != castExpr->get_arg()->get_result()->get_qualifiers() ) { + // must keep cast if cast-to type is different from the actual type + castExpr->set_arg( ret ); + return castExpr; + } + ret->set_env( castExpr->get_env() ); + delete ret->get_result(); + ret->set_result( castExpr->get_result() ); + castExpr->set_env( nullptr ); + castExpr->set_arg( nullptr ); + castExpr->set_result( nullptr ); + delete castExpr; + return ret; } else { - throw SemanticError( "Attempt to return non-lvalue from an lvalue-qualified function" ); - } // if - } // if - return retStmt; - } - - void Pass2::visit( FunctionType *funType ) { - std::string typeName; - if ( isLvalueRet( funType ) ) { - DeclarationWithType *retParm = funType->get_returnVals().front(); - - // make a new parameter that is a pointer to the type of the old return value - retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) ); - } // if - - Visitor::visit( funType ); + // rvalue to reference conversion -- introduce temporary + } + assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() ); + } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) { + (void)refType; + // conversion from reference to rvalue + PRINT( + std::cerr << "convert reference to rvalue -- *" << std::endl; + std::cerr << "was = " << castExpr << std::endl; + ) + Expression * ret = castExpr->get_arg(); + TypeSubstitution * env = castExpr->get_env(); + castExpr->set_env( nullptr ); + if ( ! isIntrinsicReference( ret ) ) { + // dereference if not already dereferenced + ret = mkDeref( ret ); + } + if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) { + // can remove cast if types are compatible, changing expression type to value type + ret->set_result( castExpr->get_result()->clone() ); + castExpr->set_arg( nullptr ); + delete castExpr; + } else { + // must keep cast if types are different + castExpr->set_arg( ret ); + ret = castExpr; + } + ret->set_env( env ); + PRINT( std::cerr << "now: " << ret << std::endl; ) + return ret; + } + return castExpr; + } + + Type * ReferenceTypeElimination::postmutate( ReferenceType * refType ) { + Type * base = refType->get_base(); + Type::Qualifiers qualifiers = refType->get_qualifiers(); + refType->set_base( nullptr ); + delete refType; + return new PointerType( qualifiers, base ); } @@ -175,14 +412,14 @@ Expression * arg1 = commaExpr->get_arg1()->clone(); Expression * arg2 = commaExpr->get_arg2()->clone(); - Expression * ret = new CommaExpr( arg1, mkExpr( arg2 ) ); + Expression * ret = new CommaExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ) ); ret->set_env( expr->get_env() ); expr->set_env( nullptr ); delete expr; - return ret->acceptMutator( *this ); + return ret; } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) { Expression * arg1 = condExpr->get_arg1()->clone(); Expression * arg2 = condExpr->get_arg2()->clone(); Expression * arg3 = condExpr->get_arg3()->clone(); - ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 ), mkExpr( arg3 ) ); + ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ), mkExpr( arg3 )->acceptMutator( *visitor ) ); ret->set_env( expr->get_env() ); expr->set_env( nullptr ); @@ -197,17 +434,54 @@ unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType ); ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() ); - return ret->acceptMutator( *this ); + return ret; } return expr; } - Expression * GeneralizedLvalue::mutate( MemberExpr * memExpr ) { - Parent::mutate( memExpr ); + Expression * GeneralizedLvalue::postmutate( MemberExpr * memExpr ) { return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } ); } - Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) { - addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) ); + Expression * GeneralizedLvalue::postmutate( AddressExpr * addrExpr ) { return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } ); + } + + Expression * CollapseAddrDeref::postmutate( AddressExpr * addrExpr ) { + Expression * arg = addrExpr->get_arg(); + if ( isIntrinsicReference( arg ) ) { + std::string fname = InitTweak::getFunctionName( arg ); + if ( fname == "*?" ) { + Expression *& arg0 = InitTweak::getCallArg( arg, 0 ); + Expression * ret = arg0; + ret->set_env( addrExpr->get_env() ); + arg0 = nullptr; + addrExpr->set_env( nullptr ); + delete addrExpr; + return ret; + } + } + return addrExpr; + } + + Expression * CollapseAddrDeref::postmutate( ApplicationExpr * appExpr ) { + if ( isIntrinsicReference( appExpr ) ) { + std::string fname = InitTweak::getFunctionName( appExpr ); + if ( fname == "*?" ) { + Expression * arg = InitTweak::getCallArg( appExpr, 0 ); + // xxx - this isn't right, because it can remove casts that should be there... + // while ( CastExpr * castExpr = dynamic_cast< CastExpr * >( arg ) ) { + // arg = castExpr->get_arg(); + // } + if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( arg ) ) { + Expression * ret = addrExpr->get_arg(); + ret->set_env( appExpr->get_env() ); + addrExpr->set_arg( nullptr ); + appExpr->set_env( nullptr ); + delete appExpr; + return ret; + } + } + } + return appExpr; } } // namespace Index: src/GenPoly/Lvalue.h =================================================================== --- src/GenPoly/Lvalue.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/GenPoly/Lvalue.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -25,4 +25,7 @@ void convertLvalue( std::list< Declaration* >& translationUnit ); + /// true after reference types have been eliminated from the source code. After this point, reference types should not be added to the AST. + bool referencesPermissable(); + /// applies transformations that allow GCC to accept more complicated lvalue expressions, e.g. &(a, b) Expression * generalizedLvalue( Expression * expr ); Index: src/GenPoly/Specialize.cc =================================================================== --- src/GenPoly/Specialize.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/GenPoly/Specialize.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -131,6 +131,6 @@ // conversion of 0 (null) to function type does not require tuple specialization if ( dynamic_cast< ZeroType * >( actualType ) ) return false; - FunctionType * aftype = getFunctionType( actualType ); - assertf( aftype, "formal type is a function type, but actual type is not." ); + FunctionType * aftype = getFunctionType( actualType->stripReferences() ); + assertf( aftype, "formal type is a function type, but actual type is not: %s", toString( actualType ).c_str() ); // Can't tuple specialize if parameter sizes deeply-differ. if ( functionParameterSize( fftype ) != functionParameterSize( aftype ) ) return false; Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/InitTweak/FixInit.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -29,4 +29,5 @@ #include "CodeGen/GenType.h" // for genPrettyType +#include "CodeGen/OperatorTable.h" #include "Common/PassVisitor.h" // for PassVisitor, WithStmtsToAdd #include "Common/SemanticError.h" // for SemanticError @@ -254,5 +255,4 @@ SemanticError errors; private: - void handleFirstParam( Expression * firstParam ); template< typename... Params > void emit( CodeLocation, const Params &... params ); @@ -379,14 +379,14 @@ FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) ); assert( ftype ); - if ( isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) { - Type * t1 = ftype->get_parameters().front()->get_type(); + if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) { + Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() ); Type * t2 = ftype->get_parameters().back()->get_type(); - PointerType * ptrType = safe_dynamic_cast< PointerType * > ( t1 ); - - if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) { + assert( t1 ); + + if ( ResolvExpr::typesCompatible( t1, t2, SymTab::Indexer() ) ) { // optimization: don't need to copy construct in order to call a copy constructor return appExpr; } // if - } else if ( isDestructor( funcDecl->get_name() ) ) { + } else if ( CodeGen::isDestructor( funcDecl->get_name() ) ) { // correctness: never copy construct arguments to a destructor return appExpr; @@ -417,5 +417,5 @@ bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { - return dynamic_cast< VarArgsType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type ); + return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type ); } @@ -505,5 +505,5 @@ impCpCtorExpr->get_returnDecls().push_back( ret ); CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; ) - if ( ! result->get_lvalue() ) { + if ( ! dynamic_cast< ReferenceType * >( result ) ) { // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary destructRet( ret, impCpCtorExpr ); @@ -607,23 +607,4 @@ Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) ); - if ( callExpr->get_result()->get_lvalue() ) { - // lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning - // non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the - // type of the return temporary from T to T* to properly capture the return value. Then dereference - // the result of the comma expression, since the lvalue returning call was originally wrapped with - // an AddressExpr. Effectively, this turns - // lvalue T f(); - // &*f(); - // into - // T * f(); - // T * tmp_cp_retN; - // &*(tmp_cp_retN = &*f(), tmp_cp_retN); // the first * and second & are generated here - // which work out in terms of types, but is pretty messy. It would be nice to find a better way. - assign->get_args().back() = new AddressExpr( assign->get_args().back() ); - - returnDecl->set_type( new PointerType( Type::Qualifiers(), returnDecl->get_type() ) ); - retExpr->set_result( new PointerType( Type::Qualifiers(), retExpr->get_result() ) ); - retExpr = UntypedExpr::createDeref( retExpr ); - } // if // move env from callExpr to retExpr retExpr->set_env( callExpr->get_env() ); @@ -991,5 +972,5 @@ if ( ! funcDecl ) return false; if ( ! funcDecl->get_statements() ) return false; - return isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() ); + return CodeGen::isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() ); } @@ -1008,11 +989,11 @@ function = funcDecl; - isCtor = isConstructor( function->get_name() ); + isCtor = CodeGen::isConstructor( function->get_name() ); if ( checkWarnings( function ) ) { FunctionType * type = function->get_functionType(); assert( ! type->get_parameters().empty() ); thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() ); - PointerType * ptrType = safe_dynamic_cast< PointerType * > ( thisParam->get_type() ); - StructInstType * structType = dynamic_cast< StructInstType * >( ptrType->get_base() ); + Type * thisType = getPointerBase( thisParam->get_type() ); + StructInstType * structType = dynamic_cast< StructInstType * >( thisType ); if ( structType ) { structDecl = structType->get_baseStruct(); @@ -1047,5 +1028,5 @@ if ( ! unhandled.empty() ) { - // need to explicitly re-add function parameters in order to resolve copy constructors + // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors enterScope(); maybeAccept( function->get_functionType(), *this ); @@ -1062,6 +1043,4 @@ // insert and resolve default/copy constructor call for each field that's unhandled std::list< Statement * > stmt; - UntypedExpr * deref = UntypedExpr::createDeref( new VariableExpr( thisParam ) ); - Expression * arg2 = 0; if ( isCopyConstructor( function ) ) { @@ -1072,5 +1051,8 @@ } InitExpander srcParam( arg2 ); - SymTab::genImplicitCall( srcParam, new MemberExpr( field, deref ), function->get_name(), back_inserter( stmt ), field, isCtor ); + // cast away reference type and construct field. + Expression * thisExpr = new CastExpr( new VariableExpr( thisParam ), thisParam->get_type()->stripReferences()->clone() ); + Expression * memberDest = new MemberExpr( field, thisExpr ); + SymTab::genImplicitCall( srcParam, memberDest, function->get_name(), back_inserter( stmt ), field, isCtor ); assert( stmt.size() <= 1 ); @@ -1099,4 +1081,27 @@ } + /// true if expr is effectively just the 'this' parameter + bool isThisExpression( Expression * expr, DeclarationWithType * thisParam ) { + // TODO: there are more complicated ways to pass 'this' to a constructor, e.g. &*, *&, etc. + if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) { + return varExpr->get_var() == thisParam; + } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * > ( expr ) ) { + return isThisExpression( castExpr->get_arg(), thisParam ); + } + return false; + } + + /// returns a MemberExpr if expr is effectively just member access on the 'this' parameter, else nullptr + MemberExpr * isThisMemberExpr( Expression * expr, DeclarationWithType * thisParam ) { + if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) { + if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) { + return memberExpr; + } + } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { + return isThisMemberExpr( castExpr->get_arg(), thisParam ); + } + return nullptr; + } + void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) { if ( ! checkWarnings( function ) ) return; @@ -1107,35 +1112,17 @@ Expression * firstParam = appExpr->get_args().front(); - if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( firstParam ) ) { + if ( isThisExpression( firstParam, thisParam ) ) { // if calling another constructor on thisParam, assume that function handles // all members - if it doesn't a warning will appear in that function. - if ( varExpr->get_var() == thisParam ) { - unhandled.clear(); - } - } else { - // if first parameter is a member expression then - // remove the member from unhandled set. - handleFirstParam( firstParam ); - } - } - - Parent::visit( appExpr ); - } - - void GenStructMemberCalls::handleFirstParam( Expression * firstParam ) { - using namespace std; - if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( firstParam ) ) { - if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( addrExpr->get_arg() ) ) { - if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) { - if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) { - if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) { - if ( varExpr->get_var() == thisParam ) { - unhandled.erase( memberExpr->get_member() ); - } - } - } + unhandled.clear(); + } else if ( MemberExpr * memberExpr = isThisMemberExpr( firstParam, thisParam ) ) { + // if first parameter is a member expression on the this parameter, + // then remove the member from unhandled set. + if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) { + unhandled.erase( memberExpr->get_member() ); } } } + Parent::visit( appExpr ); } @@ -1144,14 +1131,8 @@ if ( ! isCtor ) return; - if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) { - if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) { - if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) { - if ( varExpr->get_var() == thisParam ) { - if ( unhandled.count( memberExpr->get_member() ) ) { - // emit a warning because a member was used before it was constructed - usedUninit.insert( { memberExpr->get_member(), memberExpr->location } ); - } - } - } + if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) { + if ( unhandled.count( memberExpr->get_member() ) ) { + // emit a warning because a member was used before it was constructed + usedUninit.insert( { memberExpr->get_member(), memberExpr->location } ); } } @@ -1199,15 +1180,38 @@ ctorExpr->set_callExpr( nullptr ); ctorExpr->set_env( nullptr ); + delete ctorExpr; Expression *& firstArg = callExpr->get_args().front(); - UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) ); - assign->get_args().push_back( new VariableExpr( tmp ) ); - assign->get_args().push_back( firstArg ); - assign->set_result( ctorExpr->get_result()->clone() ); - firstArg = assign; - - CommaExpr * commaExpr = new CommaExpr( callExpr, new VariableExpr( tmp ) ); + + // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away. + + // generate the type of assignment operator using the type of tmp minus any reference types + Type * type = tmp->get_type()->stripReferences(); + FunctionType * ftype = SymTab::genAssignType( type ); + + // generate fake assignment decl and call it using &tmp and &firstArg + // since tmp is guaranteed to be a reference and we want to assign pointers + FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr ); + ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) ); + assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) ); + Expression * addrArg = new AddressExpr( firstArg ); + // if firstArg has type T&&, then &firstArg has type T*&. + // Cast away the reference to a value type so that the argument + // matches the assignment's parameter types + if ( dynamic_cast( addrArg->get_result() ) ) { + addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() ); + } + assign->get_args().push_back( addrArg ); + firstArg = new VariableExpr( tmp ); + + // for constructor expr: + // T x; + // x{}; + // results in: + // T x; + // T & tmp; + // &tmp = &x, ?{}(tmp), tmp + CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) ); commaExpr->set_env( env ); - delete ctorExpr; return commaExpr; } Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/InitTweak/GenInit.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -21,4 +21,5 @@ #include // for _List_iterator, list +#include "CodeGen/OperatorTable.h" #include "Common/PassVisitor.h" // for PassVisitor, WithGuards, WithShort... #include "Common/SemanticError.h" // for SemanticError @@ -57,5 +58,5 @@ protected: - FunctionType * ftype; + FunctionType * ftype = nullptr; std::string funcName; }; @@ -140,13 +141,11 @@ std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals(); assert( returnVals.size() == 0 || returnVals.size() == 1 ); - // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address + // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address // is being returned - if ( returnStmt->get_expr() && returnVals.size() == 1 && ! returnVals.front()->get_type()->get_lvalue() ) { + if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) { // explicitly construct the return value using the return expression and the retVal object assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() ); - UntypedExpr *construct = new UntypedExpr( new NameExpr( "?{}" ) ); - construct->get_args().push_back( new AddressExpr( new VariableExpr( returnVals.front() ) ) ); - construct->get_args().push_back( returnStmt->get_expr() ); - stmtsToAddBefore.push_back(new ExprStmt(noLabels, construct)); + + stmtsToAddBefore.push_back( genCtorDtor( "?{}", dynamic_cast< ObjectDecl *>( returnVals.front() ), returnStmt->get_expr() ) ); // return the retVal object @@ -215,4 +214,6 @@ bool CtorDtor::isManaged( Type * type ) const { + // at least for now, references are never constructed + if ( dynamic_cast< ReferenceType * >( type ) ) return false; // need to clear and reset qualifiers when determining if a type is managed ValueGuard< Type::Qualifiers > qualifiers( type->get_qualifiers() ); @@ -238,9 +239,10 @@ void CtorDtor::handleDWT( DeclarationWithType * dwt ) { // if this function is a user-defined constructor or destructor, mark down the type as "managed" - if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && isCtorDtor( dwt->get_name() ) ) { + if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) { std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters(); assert( ! params.empty() ); - PointerType * type = safe_dynamic_cast< PointerType * >( params.front()->get_type() ); - managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) ); + Type * type = InitTweak::getPointerBase( params.front()->get_type() ); + assert( type ); + managedTypes.insert( SymTab::Mangler::mangle( type ) ); } } Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/InitTweak/InitTweak.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -187,5 +187,5 @@ UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) ); - increment->get_args().push_back( new AddressExpr( index->clone() ) ); + increment->get_args().push_back( index->clone() ); *out++ = new ExprStmt( noLabels, increment ); } @@ -397,5 +397,5 @@ template Expression *& callArg( CallExpr * callExpr, unsigned int pos ) { - if ( pos >= callExpr->get_args().size() ) assertf( false, "asking for argument that doesn't exist. Return NULL/throw exception?" ); + if ( pos >= callExpr->get_args().size() ) assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.", pos, toString( callExpr ).c_str() ); for ( Expression *& arg : callExpr->get_args() ) { if ( pos == 0 ) return arg; @@ -475,4 +475,6 @@ } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) { return arrayType->get_base(); + } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) { + return refType->get_base(); } else { return NULL; @@ -560,10 +562,9 @@ if ( ftype->get_parameters().size() != 2 ) return 0; - Type * t1 = ftype->get_parameters().front()->get_type(); + Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() ); Type * t2 = ftype->get_parameters().back()->get_type(); - PointerType * ptrType = dynamic_cast< PointerType * > ( t1 ); - assert( ptrType ); - - if ( ResolvExpr::typesCompatibleIgnoreQualifiers( ptrType->get_base(), t2, SymTab::Indexer() ) ) { + assert( t1 ); + + if ( ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, SymTab::Indexer() ) ) { return function; } else { Index: src/InitTweak/InitTweak.h =================================================================== --- src/InitTweak/InitTweak.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/InitTweak/InitTweak.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -24,10 +24,4 @@ // helper functions for initialization namespace InitTweak { - bool isConstructor( const std::string & ); - bool isDestructor( const std::string & ); - bool isAssignment( const std::string & ); - bool isCtorDtor( const std::string & ); - bool isCtorDtorAssign( const std::string & ); - FunctionDecl * isAssignment( Declaration * decl ); FunctionDecl * isDestructor( Declaration * decl ); Index: src/MakeLibCfa.cc =================================================================== --- src/MakeLibCfa.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/MakeLibCfa.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -16,8 +16,9 @@ #include "MakeLibCfa.h" -#include // for assert +#include // for assert #include // for operator==, string #include "CodeGen/OperatorTable.h" // for OperatorInfo, operatorLookup, Ope... +#include "Common/PassVisitor.h" // for PassVisitor #include "Common/SemanticError.h" // for SemanticError #include "Common/UniqueName.h" // for UniqueName @@ -32,73 +33,110 @@ namespace LibCfa { - class MakeLibCfa : public Visitor { - public: - void visit( FunctionDecl* funcDecl ); - void visit( ObjectDecl* objDecl ); + namespace { + struct MakeLibCfa { + public: + void postvisit( FunctionDecl* funcDecl ); - std::list< Declaration* > &get_newDecls() { return newDecls; } - private: - std::list< Declaration* > newDecls; - }; + std::list< Declaration* > newDecls; + }; + } void makeLibCfa( std::list< Declaration* > &prelude ) { - MakeLibCfa maker; + PassVisitor maker; acceptAll( prelude, maker ); - prelude.splice( prelude.end(), maker.get_newDecls() ); + prelude.splice( prelude.end(), maker.pass.newDecls ); } - void MakeLibCfa::visit( FunctionDecl* origFuncDecl ) { - if ( origFuncDecl->get_linkage() != LinkageSpec::Intrinsic ) return; - if ( origFuncDecl->get_statements() ) return; + namespace { + struct TypeFinder { + void postvisit( TypeInstType * inst ) { + // if a type variable is seen, assume all zero_t/one_t in the parameter list + // can be replaced with the equivalent 'general' pointer. + if ( type ) return; + if ( inst->isFtype ) { + type = new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), false ) ); + } else { + type = new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ); + } + } + Type * type = nullptr; + }; - FunctionDecl *funcDecl = origFuncDecl->clone(); - CodeGen::OperatorInfo opInfo; - bool lookResult = CodeGen::operatorLookup( funcDecl->get_name(), opInfo ); - assert( lookResult ); - assert( ! funcDecl->get_statements() ); - UntypedExpr *newExpr = new UntypedExpr( new NameExpr( funcDecl->get_name() ) ); - UniqueName paramNamer( "_p" ); - std::list< DeclarationWithType* >::iterator param = funcDecl->get_functionType()->get_parameters().begin(); - assert( param != funcDecl->get_functionType()->get_parameters().end() ); + struct ZeroOneReplacer { + ZeroOneReplacer( Type * t ) : type( t ) {} + ~ZeroOneReplacer() { delete type; } + Type * type = nullptr; - for ( ; param != funcDecl->get_functionType()->get_parameters().end(); ++param ) { - if ( (*param)->get_name() == "" ) { - (*param)->set_name( paramNamer.newName() ); - (*param)->set_linkage( LinkageSpec::C ); + Type * common( Type * t ) { + if ( ! type ) return t; + delete t; + return type->clone(); } - newExpr->get_args().push_back( new VariableExpr( *param ) ); - } // for - funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) ); - newDecls.push_back( funcDecl ); + Type * postmutate( OneType * t ) { return common( t ); } + Type * postmutate( ZeroType * t ) { return common( t ); } + }; - switch ( opInfo.type ) { - case CodeGen::OT_INDEX: - case CodeGen::OT_CALL: - case CodeGen::OT_PREFIX: - case CodeGen::OT_POSTFIX: - case CodeGen::OT_INFIX: - case CodeGen::OT_PREFIXASSIGN: - case CodeGen::OT_POSTFIXASSIGN: - case CodeGen::OT_INFIXASSIGN: - case CodeGen::OT_CTOR: - case CodeGen::OT_DTOR: - funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) ); - break; - case CodeGen::OT_CONSTANT: - case CodeGen::OT_LABELADDRESS: - // there are no intrinsic definitions of 0/1 or label addresses as functions - assert( false ); - } // switch - } + void fixZeroOneType( FunctionDecl * origFuncDecl ) { + // find appropriate type to replace zero_t/one_t with + PassVisitor finder; + origFuncDecl->type->accept( finder ); + // replace zero_t/one_t in function type + PassVisitor replacer( finder.pass.type ); + origFuncDecl->type->acceptMutator( replacer ); + } - void MakeLibCfa::visit( ObjectDecl* origObjDecl ) { - if ( origObjDecl->get_linkage() != LinkageSpec::Intrinsic ) return; + void MakeLibCfa::postvisit( FunctionDecl* origFuncDecl ) { + // don't change non-intrinsic functions + if ( origFuncDecl->get_linkage() != LinkageSpec::Intrinsic ) return; + // replace zero_t/one_t with void */void (*)(void) + fixZeroOneType( origFuncDecl ); + // skip functions already defined + if ( origFuncDecl->get_statements() ) return; - ObjectDecl *objDecl = origObjDecl->clone(); - assert( ! objDecl->get_init() ); - std::list< Expression* > noDesignators; - objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), false ) ); // cannot be constructed - newDecls.push_back( objDecl ); - } + FunctionDecl *funcDecl = origFuncDecl->clone(); + CodeGen::OperatorInfo opInfo; + bool lookResult = CodeGen::operatorLookup( funcDecl->get_name(), opInfo ); + assert( lookResult ); + assert( ! funcDecl->get_statements() ); + // build a recursive call - this is okay, as the call will actually be codegen'd using operator syntax + UntypedExpr *newExpr = new UntypedExpr( new NameExpr( funcDecl->get_name() ) ); + UniqueName paramNamer( "_p" ); + std::list< DeclarationWithType* >::iterator param = funcDecl->get_functionType()->get_parameters().begin(); + assert( param != funcDecl->get_functionType()->get_parameters().end() ); + + for ( ; param != funcDecl->get_functionType()->get_parameters().end(); ++param ) { + // name each unnamed parameter + if ( (*param)->get_name() == "" ) { + (*param)->set_name( paramNamer.newName() ); + (*param)->set_linkage( LinkageSpec::C ); + } + // add parameter to the expression + newExpr->get_args().push_back( new VariableExpr( *param ) ); + } // for + + funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) ); + newDecls.push_back( funcDecl ); + + switch ( opInfo.type ) { + case CodeGen::OT_INDEX: + case CodeGen::OT_CALL: + case CodeGen::OT_PREFIX: + case CodeGen::OT_POSTFIX: + case CodeGen::OT_INFIX: + case CodeGen::OT_PREFIXASSIGN: + case CodeGen::OT_POSTFIXASSIGN: + case CodeGen::OT_INFIXASSIGN: + case CodeGen::OT_CTOR: + case CodeGen::OT_DTOR: + // return the recursive call + funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) ); + break; + case CodeGen::OT_CONSTANT: + case CodeGen::OT_LABELADDRESS: + // there are no intrinsic definitions of 0/1 or label addresses as functions + assert( false ); + } // switch + } + } // namespace } // namespace LibCfa Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Makefile.in (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -224,4 +224,5 @@ SynTree/driver_cfa_cpp-PointerType.$(OBJEXT) \ SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT) \ + SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT) \ SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT) \ SynTree/driver_cfa_cpp-ReferenceToType.$(OBJEXT) \ @@ -520,6 +521,7 @@ SynTree/VoidType.cc SynTree/BasicType.cc \ SynTree/PointerType.cc SynTree/ArrayType.cc \ - SynTree/FunctionType.cc SynTree/ReferenceToType.cc \ - SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \ + SynTree/ReferenceType.cc SynTree/FunctionType.cc \ + SynTree/ReferenceToType.cc SynTree/TupleType.cc \ + SynTree/TypeofType.cc SynTree/AttrType.cc \ SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \ SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \ @@ -867,4 +869,6 @@ SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \ SynTree/$(DEPDIR)/$(am__dirstamp) +SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT): \ + SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp) SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT): \ SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp) @@ -1070,4 +1074,5 @@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-PointerType.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceToType.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Statement.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TupleExpr.Po@am__quote@ @@ -2167,4 +2172,18 @@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ArrayType.obj `if test -f 'SynTree/ArrayType.cc'; then $(CYGPATH_W) 'SynTree/ArrayType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ArrayType.cc'; fi` + +SynTree/driver_cfa_cpp-ReferenceType.o: SynTree/ReferenceType.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc + +SynTree/driver_cfa_cpp-ReferenceType.obj: SynTree/ReferenceType.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi` SynTree/driver_cfa_cpp-FunctionType.o: SynTree/FunctionType.cc Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Parser/DeclarationNode.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -340,7 +340,7 @@ } // DeclarationNode::newTypeDecl -DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers ) { - DeclarationNode * newnode = new DeclarationNode; - newnode->type = new TypeData( TypeData::Pointer ); +DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers, OperKinds kind ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->type = new TypeData( kind == OperKinds::PointTo ? TypeData::Pointer : TypeData::Reference ); if ( qualifiers ) { return newnode->addQualifiers( qualifiers ); @@ -759,5 +759,5 @@ DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) { if ( p ) { - assert( p->type->kind == TypeData::Pointer ); + assert( p->type->kind == TypeData::Pointer || TypeData::Reference ); setBase( p->type ); p->type = nullptr; @@ -781,5 +781,5 @@ DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode * p ) { if ( p ) { - assert( p->type->kind == TypeData::Pointer ); + assert( p->type->kind == TypeData::Pointer || p->type->kind == TypeData::Reference ); if ( type ) { switch ( type->kind ) { Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Parser/ExpressionNode.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -314,5 +314,5 @@ Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) { std::list< Expression * > args; - args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node) ) ); + args.push_back( maybeMoveBuild< Expression >(expr_node) ); // xxx return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); } // build_unary_ptr @@ -327,5 +327,5 @@ Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) { std::list< Expression * > args; - args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node1) ) ); + args.push_back( maybeMoveBuild< Expression >(expr_node1) ); args.push_back( maybeMoveBuild< Expression >(expr_node2) ); return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Parser/ParseNode.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -243,5 +243,5 @@ static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params ); static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams ); - static DeclarationNode * newPointer( DeclarationNode * qualifiers ); + static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind ); static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic ); static DeclarationNode * newVarArray( DeclarationNode * qualifiers ); Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Parser/TypeData.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -35,4 +35,5 @@ case Unknown: case Pointer: + case Reference: case EnumConstant: // nothing else to initialize @@ -104,4 +105,5 @@ case Unknown: case Pointer: + case Reference: case EnumConstant: // nothing to destroy @@ -170,4 +172,5 @@ case EnumConstant: case Pointer: + case Reference: // nothing else to copy break; @@ -405,10 +408,10 @@ // add dtor: void ^?{}(T *) FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false ); - dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); td->get_assertions().push_front( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) ); // add copy ctor: void ?{}(T *, T) FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false ); - copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) ); @@ -416,10 +419,10 @@ // add default ctor: void ?{}(T *) FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false ); - ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) ); // add assignment operator: T * ?=?(T *, T) FunctionType * assignType = new FunctionType( Type::Qualifiers(), false ); - assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); assignType->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); @@ -441,4 +444,6 @@ case TypeData::Array: return buildArray( td ); + case TypeData::Reference: + return buildReference( td ); case TypeData::Function: return buildFunction( td ); @@ -619,5 +624,16 @@ buildForall( td->forall, at->get_forall() ); return at; -} // buildPointer +} // buildArray + +ReferenceType * buildReference( const TypeData * td ) { + ReferenceType * rt; + if ( td->base ) { + rt = new ReferenceType( buildQualifiers( td ), typebuild( td->base ) ); + } else { + rt = new ReferenceType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ); + } // if + buildForall( td->forall, rt->get_forall() ); + return rt; +} // buildReference AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) { Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Parser/TypeData.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -26,5 +26,5 @@ struct TypeData { - enum Kind { Basic, Pointer, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic, + enum Kind { Basic, Pointer, Array, Reference, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic, SymbolicInst, Tuple, Typeof, Builtin, Unknown }; @@ -109,4 +109,5 @@ PointerType * buildPointer( const TypeData * ); ArrayType * buildArray( const TypeData * ); +ReferenceType * buildReference( const TypeData * ); AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > ); ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ); Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Parser/lex.ll (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -237,5 +237,4 @@ __label__ { KEYWORD_RETURN(LABEL); } // GCC long { KEYWORD_RETURN(LONG); } -lvalue { KEYWORD_RETURN(LVALUE); } // CFA monitor { KEYWORD_RETURN(MONITOR); } // CFA mutex { KEYWORD_RETURN(MUTEX); } // CFA Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Parser/parser.yy (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -119,5 +119,5 @@ %token RESTRICT // C99 %token ATOMIC // C11 -%token FORALL LVALUE MUTEX VIRTUAL // CFA +%token FORALL MUTEX VIRTUAL // CFA %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED %token BOOL COMPLEX IMAGINARY // C99 @@ -687,5 +687,5 @@ conditional_expression | unary_expression assignment_operator assignment_expression - { $$ = new ExpressionNode( build_binary_ptr( $2, $1, $3 ) ); } + { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); } ; @@ -1483,6 +1483,4 @@ | VOLATILE { $$ = DeclarationNode::newTypeQualifier( Type::Volatile ); } - | LVALUE // CFA - { $$ = DeclarationNode::newTypeQualifier( Type::Lvalue ); } | MUTEX { $$ = DeclarationNode::newTypeQualifier( Type::Mutex ); } @@ -2466,7 +2464,7 @@ variable_ptr: ptrref_operator variable_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); } | ptrref_operator type_qualifier_list variable_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); } | '(' variable_ptr ')' attribute_list_opt { $$ = $2->addQualifiers( $4 ); } // redundant parenthesis @@ -2514,7 +2512,7 @@ function_ptr: ptrref_operator function_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); } | ptrref_operator type_qualifier_list function_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); } | '(' function_ptr ')' { $$ = $2; } @@ -2554,7 +2552,7 @@ KR_function_ptr: ptrref_operator KR_function_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); } | ptrref_operator type_qualifier_list KR_function_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); } | '(' KR_function_ptr ')' { $$ = $2; } @@ -2598,7 +2596,7 @@ type_ptr: ptrref_operator variable_type_redeclarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); } | ptrref_operator type_qualifier_list variable_type_redeclarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); } | '(' type_ptr ')' attribute_list_opt { $$ = $2->addQualifiers( $4 ); } @@ -2642,7 +2640,7 @@ identifier_parameter_ptr: ptrref_operator identifier_parameter_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); } | ptrref_operator type_qualifier_list identifier_parameter_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); } | '(' identifier_parameter_ptr ')' attribute_list_opt { $$ = $2->addQualifiers( $4 ); } @@ -2702,7 +2700,7 @@ type_parameter_ptr: ptrref_operator type_parameter_redeclarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); } | ptrref_operator type_qualifier_list type_parameter_redeclarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); } | '(' type_parameter_ptr ')' attribute_list_opt { $$ = $2->addQualifiers( $4 ); } @@ -2745,11 +2743,11 @@ abstract_ptr: ptrref_operator - { $$ = DeclarationNode::newPointer( 0 ); } + { $$ = DeclarationNode::newPointer( 0, $1 ); } | ptrref_operator type_qualifier_list - { $$ = DeclarationNode::newPointer( $2 ); } + { $$ = DeclarationNode::newPointer( $2, $1 ); } | ptrref_operator abstract_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); } | ptrref_operator type_qualifier_list abstract_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); } | '(' abstract_ptr ')' attribute_list_opt { $$ = $2->addQualifiers( $4 ); } @@ -2834,11 +2832,11 @@ abstract_parameter_ptr: ptrref_operator - { $$ = DeclarationNode::newPointer( nullptr ); } + { $$ = DeclarationNode::newPointer( nullptr, $1 ); } | ptrref_operator type_qualifier_list - { $$ = DeclarationNode::newPointer( $2 ); } + { $$ = DeclarationNode::newPointer( $2, $1 ); } | ptrref_operator abstract_parameter_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr ) ); } + { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); } | ptrref_operator type_qualifier_list abstract_parameter_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); } | '(' abstract_parameter_ptr ')' attribute_list_opt { $$ = $2->addQualifiers( $4 ); } @@ -2913,11 +2911,11 @@ variable_abstract_ptr: ptrref_operator - { $$ = DeclarationNode::newPointer( 0 ); } + { $$ = DeclarationNode::newPointer( 0, $1 ); } | ptrref_operator type_qualifier_list - { $$ = DeclarationNode::newPointer( $2 ); } + { $$ = DeclarationNode::newPointer( $2, $1 ); } | ptrref_operator variable_abstract_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); } | ptrref_operator type_qualifier_list variable_abstract_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); } | '(' variable_abstract_ptr ')' attribute_list_opt { $$ = $2->addQualifiers( $4 ); } @@ -2959,15 +2957,15 @@ // No SUE declaration in parameter list. ptrref_operator type_specifier_nobody - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); } | type_qualifier_list ptrref_operator type_specifier_nobody - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); } | ptrref_operator cfa_abstract_function - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); } | type_qualifier_list ptrref_operator cfa_abstract_function - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); } | ptrref_operator cfa_identifier_parameter_declarator_tuple - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); } | type_qualifier_list ptrref_operator cfa_identifier_parameter_declarator_tuple - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); } ; @@ -3047,15 +3045,15 @@ cfa_abstract_ptr: // CFA ptrref_operator type_specifier - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); } | type_qualifier_list ptrref_operator type_specifier - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); } | ptrref_operator cfa_abstract_function - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); } | type_qualifier_list ptrref_operator cfa_abstract_function - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); } | ptrref_operator cfa_abstract_declarator_tuple - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); } | type_qualifier_list ptrref_operator cfa_abstract_declarator_tuple - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); } ; Index: src/ResolvExpr/Alternative.cc =================================================================== --- src/ResolvExpr/Alternative.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/Alternative.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -34,11 +34,14 @@ : cost( cost ), cvtCost( cvtCost ), expr( expr ), env( env ) {} - Alternative::Alternative( const Alternative &other ) { - initialize( other, *this ); + Alternative::Alternative( const Alternative &other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( maybeClone( other.expr ) ), env( other.env ) { } Alternative &Alternative::operator=( const Alternative &other ) { if ( &other == this ) return *this; - initialize( other, *this ); + delete expr; + cost = other.cost; + cvtCost = other.cvtCost; + expr = maybeClone( other.expr ); + env = other.env; return *this; } @@ -57,11 +60,4 @@ other.expr = nullptr; return *this; - } - - void Alternative::initialize( const Alternative &src, Alternative &dest ) { - dest.cost = src.cost; - dest.cvtCost = src.cvtCost; - dest.expr = maybeClone( src.expr ); - dest.env = src.env; } Index: src/ResolvExpr/Alternative.h =================================================================== --- src/ResolvExpr/Alternative.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/Alternative.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -39,6 +39,4 @@ ~Alternative(); - void initialize( const Alternative &src, Alternative &dest ); - void print( std::ostream &os, int indent = 0 ) const; Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/AlternativeFinder.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -67,5 +67,5 @@ Cost sumCost( const AltList &in ) { - Cost total; + Cost total = Cost::zero; for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) { total += i->cost; @@ -144,5 +144,12 @@ expr->get_result()->accept( global_renamer ); } - } + + void referenceToRvalueConversion( Expression *& expr ) { + if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) { + // cast away reference from expr + expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() ); + } + } + } // namespace template< typename InputIterator, typename OutputIterator > @@ -186,9 +193,9 @@ if ( alternatives.begin() == oldBegin ) { std::ostringstream stream; - stream << "Can't choose between " << alternatives.size() << " alternatives for expression "; + AltList winners; + findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) ); + stream << "Can't choose between " << winners.size() << " alternatives for expression "; expr->print( stream ); stream << "Alternatives are:"; - AltList winners; - findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) ); printAlts( winners, stream, 8 ); throw SemanticError( stream.str() ); @@ -213,13 +220,19 @@ void AlternativeFinder::addAnonConversions( const Alternative & alt ) { // adds anonymous member interpretations whenever an aggregate value type is seen. - Expression * expr = alt.expr->clone(); - std::unique_ptr< Expression > manager( expr ); // RAII for expr - alt.env.apply( expr->get_result() ); - if ( StructInstType *structInst = dynamic_cast< StructInstType* >( expr->get_result() ) ) { + // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value + std::unique_ptr aggrExpr( alt.expr->clone() ); + alt.env.apply( aggrExpr->get_result() ); + Type * aggrType = aggrExpr->get_result(); + if ( dynamic_cast< ReferenceType * >( aggrType ) ) { + aggrType = aggrType->stripReferences(); + aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) ); + } + + if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) { NameExpr nameExpr( "" ); - addAggMembers( structInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr ); - } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( expr->get_result() ) ) { + addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr ); + } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) { NameExpr nameExpr( "" ); - addAggMembers( unionInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr ); + addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr ); } // if } @@ -228,5 +241,6 @@ void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { // by this point, member must be a name expr - NameExpr * nameExpr = safe_dynamic_cast< NameExpr * >( member ); + NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ); + if ( ! nameExpr ) return; const std::string & name = nameExpr->get_name(); std::list< Declaration* > members; @@ -250,5 +264,5 @@ // during parsing and reusing that information here. std::stringstream ss( constantExpr->get_constant()->get_value() ); - int val; + int val = 0; std::string tmp; if ( ss >> val && ! (ss >> tmp) ) { @@ -277,5 +291,5 @@ FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() ); - Cost convCost( 0, 0, 0 ); + Cost convCost = Cost::zero; std::list< DeclarationWithType* >& formals = function->get_parameters(); std::list< DeclarationWithType* >::iterator formal = formals.begin(); @@ -290,8 +304,10 @@ actualType->print( std::cerr, 8 ); ) - Cost actualCost; + Cost actualCost = Cost::zero; if ( formal == formals.end() ) { if ( function->get_isVarArgs() ) { - convCost += Cost( 1, 0, 0 ); + convCost.incUnsafe(); + // convert reference-typed expressions to value-typed expressions + referenceToRvalueConversion( *actualExpr ); continue; } else { @@ -305,4 +321,7 @@ std::cerr << std::endl << " to "; formalType->print( std::cerr, 8 ); + std::cerr << std::endl << "environment is: "; + alt.env.print( std::cerr, 8 ); + std::cerr << std::endl; ) Cost newCost = conversionCost( actualType, formalType, indexer, alt.env ); @@ -316,10 +335,10 @@ convCost += newCost; actualCost += newCost; - if ( actualCost != Cost( 0, 0, 0 ) ) { + if ( actualCost != Cost::zero ) { Type *newType = formalType->clone(); alt.env.apply( newType ); *actualExpr = new CastExpr( *actualExpr, newType ); } - convCost += Cost( 0, polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ), 0 ); + convCost.incPoly( polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ) ); ++formal; // can't be in for-loop update because of the continue } @@ -343,5 +362,5 @@ } convCost += newCost; - convCost += Cost( 0, polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ), 0 ); + convCost.incPoly( polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ) ); } @@ -400,4 +419,5 @@ Expression * actual = actualIt->expr; Type * actualType = actual->get_result(); + PRINT( std::cerr << "formal type is "; @@ -408,4 +428,5 @@ ) if ( ! unify( formalType, actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) { + // std::cerr << "unify failed" << std::endl; return false; } @@ -452,5 +473,5 @@ // match flattened actuals with formal parameters - actuals will be grouped to match // with formals as appropriate - Cost cost; + Cost cost = Cost::zero; std::list< Expression * > newExprs; ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal ); @@ -613,4 +634,10 @@ AssertionSet newNeed; //AssertionParentSet needParents; + PRINT( + std::cerr << "env is: " << std::endl; + newAlt.env.print( std::cerr, 0 ); + std::cerr << std::endl; + ) + inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, /*needParents,*/ 0, indexer, out ); // PRINT( @@ -643,4 +670,5 @@ makeExprList( instantiatedActuals, appExpr->get_args() ); PRINT( + std::cerr << "instantiate function success: " << appExpr << std::endl; std::cerr << "need assertions:" << std::endl; printAssertionSet( resultNeed, std::cerr, 8 ); @@ -663,5 +691,5 @@ UntypedExpr *vexpr = untypedExpr->clone(); vexpr->set_result( pt.clone() ); - alternatives.push_back( Alternative( vexpr, env, Cost()) ); + alternatives.push_back( Alternative( vexpr, env, Cost::zero) ); return; } @@ -681,5 +709,5 @@ AltList candidates; SemanticError errors; - for ( AltList::const_iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) { + for ( AltList::iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) { try { PRINT( @@ -688,7 +716,7 @@ ) // check if the type is pointer to function - PointerType *pointer; - if ( ( pointer = dynamic_cast< PointerType* >( func->expr->get_result() ) ) ) { + if ( PointerType *pointer = dynamic_cast< PointerType* >( func->expr->get_result()->stripReferences() ) ) { if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) { + referenceToRvalueConversion( func->expr ); for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) { // XXX @@ -696,12 +724,13 @@ makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) ); } - } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) { - EqvClass eqvClass; - if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) { - if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) { - for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) { - makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) ); - } // for - } // if + } + } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->get_result()->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer) + referenceToRvalueConversion( func->expr ); + EqvClass eqvClass; + if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) { + if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) { + for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) { + makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) ); + } // for } // if } // if @@ -722,9 +751,9 @@ } - for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) { + for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) { // check if the type is pointer to function - PointerType *pointer; - if ( ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result() ) ) ) { + if ( PointerType *pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result()->stripReferences() ) ) { if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) { + referenceToRvalueConversion( funcOp->expr ); for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) { AltList currentAlt; @@ -753,5 +782,5 @@ PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() ); FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() ); - std::cerr << "Case +++++++++++++" << std::endl; + std::cerr << "Case +++++++++++++ " << appExpr->get_function() << std::endl; std::cerr << "formals are:" << std::endl; printAll( function->get_parameters(), std::cerr, 8 ); @@ -796,5 +825,5 @@ bool isLvalue( Expression *expr ) { // xxx - recurse into tuples? - return expr->has_result() && expr->get_result()->get_lvalue(); + return expr->has_result() && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) ); } @@ -810,10 +839,11 @@ Expression * restructureCast( Expression * argExpr, Type * toType ) { - if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) { - // Argument expression is a tuple and the target type is not void. Cast each member of the tuple - // to its corresponding target type, producing the tuple of those cast expressions. If there are - // more components of the tuple than components in the target type, then excess components do not - // come out in the result expression (but UniqueExprs ensure that side effects will still be done). - if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) { + if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() && ! dynamic_cast( toType ) ) { + // Argument expression is a tuple and the target type is not void and not a reference type. + // Cast each member of the tuple to its corresponding target type, producing the tuple of those + // cast expressions. If there are more components of the tuple than components in the target type, + // then excess components do not come out in the result expression (but UniqueExprs ensure that + // side effects will still be done). + if ( Tuples::maybeImpureIgnoreUnique( argExpr ) ) { // expressions which may contain side effects require a single unique instance of the expression. argExpr = new UniqueExpr( argExpr ); @@ -855,14 +885,14 @@ // that are cast directly. The candidate is invalid if it has fewer results than there are types to cast // to. - int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size(); + int discardedValues = i->expr->get_result()->size() - castExpr->get_result()->size(); if ( discardedValues < 0 ) continue; // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3])) // unification run for side-effects - unify( castExpr->get_result(), (*i).expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer ); - Cost thisCost = castCost( (*i).expr->get_result(), castExpr->get_result(), indexer, i->env ); + unify( castExpr->get_result(), i->expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer ); + Cost thisCost = castCost( i->expr->get_result(), castExpr->get_result(), indexer, i->env ); if ( thisCost != Cost::infinity ) { // count one safe conversion for each value that is thrown away - thisCost += Cost( 0, 0, discardedValues ); + thisCost.incSafe( discardedValues ); candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) ); @@ -895,10 +925,18 @@ funcFinder.findWithAdjustment( memberExpr->get_aggregate() ); for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) { - if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) { - addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() ); - } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_result() ) ) { - addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() ); - } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( agg->expr->get_result() ) ) { - addTupleMembers( tupleType, agg->expr, agg->cost, agg->env, memberExpr->get_member() ); + // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value + std::unique_ptr aggrExpr( agg->expr->clone() ); + Type * aggrType = aggrExpr->get_result(); + if ( dynamic_cast< ReferenceType * >( aggrType ) ) { + aggrType = aggrType->stripReferences(); + aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) ); + } + // find member of the given type + if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) { + addAggMembers( structInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() ); + } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) { + addAggMembers( unionInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() ); + } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) { + addTupleMembers( tupleType, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() ); } // if } // for @@ -915,5 +953,5 @@ for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) { VariableExpr newExpr( *i, nameExpr->get_argName() ); - alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) ); + alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) ); PRINT( std::cerr << "decl is "; @@ -955,4 +993,5 @@ // return the lowest cost alternative for the argument Alternative &choice = winners.front(); + referenceToRvalueConversion( choice.expr ); alternatives.push_back( Alternative( new SizeofExpr( choice.expr->clone() ), choice.env, Cost::zero ) ); } // if @@ -975,4 +1014,5 @@ // return the lowest cost alternative for the argument Alternative &choice = winners.front(); + referenceToRvalueConversion( choice.expr ); alternatives.push_back( Alternative( new AlignofExpr( choice.expr->clone() ), choice.env, Cost::zero ) ); } // if @@ -1059,5 +1099,5 @@ for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) { VariableExpr newExpr( *i ); - alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) ); + alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) ); renameTypes( alternatives.back().expr ); } // for @@ -1232,5 +1272,5 @@ if ( thisCost != Cost::infinity ) { // count one safe conversion for each value that is thrown away - thisCost += Cost( 0, 0, discardedValues ); + thisCost.incSafe( discardedValues ); candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) ); } Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/CastCost.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -49,12 +49,14 @@ assert( type ); if ( type->get_base() ) { - return castCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 ); + return castCost( src, type->get_base(), indexer, env ) + Cost::safe; } // if } // if } // if if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) { - return Cost( 0, 0, 0 ); + return Cost::zero; } else if ( dynamic_cast< VoidType* >( dest ) ) { - return Cost( 0, 0, 1 ); + return Cost::safe; + } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) { + return convertToReferenceCost( src, refType, indexer, env ); } else { CastCost converter( dest, indexer, env ); @@ -64,5 +66,5 @@ } else { // xxx - why are we adding cost 0 here? - return converter.get_cost() + Cost( 0, 0, 0 ); + return converter.get_cost() + Cost::zero; } // if } // if @@ -77,7 +79,7 @@ if ( destAsPointer && basicType->isInteger() ) { // necessary for, e.g. unsigned long => void* - cost = Cost( 1, 0, 0 ); + cost = Cost::unsafe; } else { - ConversionCost::visit( basicType ); + cost = conversionCost( basicType, dest, indexer, env ); } // if } @@ -86,5 +88,5 @@ if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) { if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) { - cost = Cost( 0, 0, 1 ); + cost = Cost::safe; } else { TypeEnvironment newEnv( env ); @@ -93,5 +95,5 @@ int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer ); if ( castResult > 0 ) { - cost = Cost( 0, 0, 1 ); + cost = Cost::safe; } else if ( castResult < 0 ) { cost = Cost::infinity; @@ -101,5 +103,5 @@ if ( destAsBasic->isInteger() ) { // necessary for, e.g. void* => unsigned long - cost = Cost( 1, 0, 0 ); + cost = Cost::unsafe; } // if } Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/CommonType.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -26,6 +26,5 @@ #include "typeops.h" // for isFtype - -/// #define DEBUG +// #define DEBUG namespace ResolvExpr { @@ -39,4 +38,5 @@ virtual void visit( PointerType *pointerType ); virtual void visit( ArrayType *arrayType ); + virtual void visit( ReferenceType *refType ); virtual void visit( FunctionType *functionType ); virtual void visit( StructInstType *aggregateUseType ); @@ -50,5 +50,6 @@ virtual void visit( OneType *oneType ); - void getCommonWithVoidPointer( PointerType* voidPointer, PointerType* otherPointer ); + template< typename Pointer > void getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ); + template< typename RefType > void handleRefType( RefType *inst, Type *other ); Type *result; @@ -60,6 +61,50 @@ }; + Type * handleReference( ReferenceType * refType, Type * other, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment & env, const OpenVarSet &openVars ) { + Type * result = nullptr, * common = nullptr; + AssertionSet have, need; + OpenVarSet newOpen( openVars ); + // need unify to bind type variables + if ( unify( refType->get_base(), other, env, have, need, newOpen, indexer, common ) ) { + // std::cerr << "unify success" << std::endl; + if ( widenSecond ) { + // std::cerr << "widen second" << std::endl; + if ( widenFirst || other->get_qualifiers() <= refType->get_qualifiers() ) { + result = new ReferenceType( refType->get_qualifiers(), common ); // refType->clone(); + result->get_qualifiers() |= other->get_qualifiers(); + } + } else if ( widenFirst ) { + // std::cerr << "widen first" << std::endl; + if ( widenSecond || refType->get_qualifiers() <= other->get_qualifiers() ) { + result = common; + result->get_qualifiers() |= refType->get_qualifiers(); + } + } + } else { + // std::cerr << "exact unify failed: " << refType << " " << other << std::endl; + } + // std::cerr << "common type of reference [" << refType << "] and non-reference [" << other << "] is [" << result << "]" << std::endl; + return result; + } + Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) { CommonType visitor( type2, widenFirst, widenSecond, indexer, env, openVars ); + + int depth1 = type1->referenceDepth(); + int depth2 = type2->referenceDepth(); + if ( depth1 > 0 || depth2 > 0 ) { + int diff = depth1-depth2; + // TODO: should it be possible for commonType to generate complicated conversions? I would argue no, only conversions that involve types of the same reference level or a difference of 1 should be allowed. + if ( diff > 1 || diff < -1 ) return nullptr; + + // special case where one type has a reference depth of 1 larger than the other + if ( diff > 0 ) { + return handleReference( safe_dynamic_cast( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars ); + } else if ( diff < 0 ) { + return handleReference( safe_dynamic_cast( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars ); + } + // otherwise, both are reference types of the same depth and this is handled by the CommonType visitor. + } + type1->accept( visitor ); Type *result = visitor.get_result(); @@ -88,15 +133,15 @@ } // if #ifdef DEBUG - std::cout << "============= commonType" << std::endl << "type1 is "; - type1->print( std::cout ); - std::cout << " type2 is "; - type2->print( std::cout ); + std::cerr << "============= commonType" << std::endl << "type1 is "; + type1->print( std::cerr ); + std::cerr << " type2 is "; + type2->print( std::cerr ); if ( result ) { - std::cout << " common type is "; - result->print( std::cout ); + std::cerr << " common type is "; + result->print( std::cerr ); } else { - std::cout << " no common type"; - } // if - std::cout << std::endl; + std::cerr << " no common type"; + } // if + std::cerr << std::endl; #endif return result; @@ -150,5 +195,6 @@ } - void CommonType::getCommonWithVoidPointer( PointerType* voidPointer, PointerType* otherPointer ) { + template< typename Pointer > + void CommonType::getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ) { if ( TypeInstType* var = dynamic_cast< TypeInstType* >( otherPointer->get_base() ) ) { OpenVarSet::const_iterator entry = openVars.find( var->get_name() ); @@ -165,4 +211,5 @@ void CommonType::visit( PointerType *pointerType ) { if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) { + // std::cerr << "commonType: two pointers: " << pointerType << " / " << otherPointer << std::endl; if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base()) ) { getCommonWithVoidPointer( otherPointer, pointerType ); @@ -171,4 +218,5 @@ } else if ( ( pointerType->get_base()->get_qualifiers() >= otherPointer->get_base()->get_qualifiers() || widenFirst ) && ( pointerType->get_base()->get_qualifiers() <= otherPointer->get_base()->get_qualifiers() || widenSecond ) ) { + // std::cerr << "middle case" << std::endl; Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers(), tq2 = otherPointer->get_base()->get_qualifiers(); pointerType->get_base()->get_qualifiers() = Type::Qualifiers(); @@ -177,4 +225,5 @@ OpenVarSet newOpen( openVars ); if ( unifyExact( pointerType->get_base(), otherPointer->get_base(), env, have, need, newOpen, indexer ) ) { + // std::cerr << "unifyExact success" << std::endl; if ( tq1 < tq2 ) { result = pointerType->clone(); @@ -184,5 +233,5 @@ result->get_qualifiers() = tq1 | tq2; } else { - /// std::cout << "place for ptr-to-type" << std::endl; + /// std::cerr << "place for ptr-to-type" << std::endl; } // if pointerType->get_base()->get_qualifiers() = tq1; @@ -196,4 +245,40 @@ void CommonType::visit( __attribute((unused)) ArrayType *arrayType ) {} + + void CommonType::visit( ReferenceType *refType ) { + if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) { + // std::cerr << "commonType: both references: " << refType << " / " << otherRef << std::endl; + // std::cerr << ( refType->get_base()->get_qualifiers() >= otherRef->get_base()->get_qualifiers() || widenFirst ) << (refType->get_base()->get_qualifiers() <= otherRef->get_base()->get_qualifiers() || widenSecond) << std::endl; + if ( widenFirst && dynamic_cast< VoidType* >( otherRef->get_base() ) && ! isFtype(refType->get_base()) ) { + getCommonWithVoidPointer( otherRef, refType ); + } else if ( widenSecond && dynamic_cast< VoidType* >( refType->get_base() ) && ! isFtype(otherRef->get_base()) ) { + getCommonWithVoidPointer( refType, otherRef ); + } else if ( ( refType->get_base()->get_qualifiers() >= otherRef->get_base()->get_qualifiers() || widenFirst ) + && ( refType->get_base()->get_qualifiers() <= otherRef->get_base()->get_qualifiers() || widenSecond ) ) { + // std::cerr << "middle case" << std::endl; + Type::Qualifiers tq1 = refType->get_base()->get_qualifiers(), tq2 = otherRef->get_base()->get_qualifiers(); + refType->get_base()->get_qualifiers() = Type::Qualifiers(); + otherRef->get_base()->get_qualifiers() = Type::Qualifiers(); + AssertionSet have, need; + OpenVarSet newOpen( openVars ); + if ( unifyExact( refType->get_base(), otherRef->get_base(), env, have, need, newOpen, indexer ) ) { + if ( tq1 < tq2 ) { + result = refType->clone(); + } else { + result = otherRef->clone(); + } // if + result->get_qualifiers() = tq1 | tq2; + } else { + /// std::cerr << "place for ptr-to-type" << std::endl; + } // if + refType->get_base()->get_qualifiers() = tq1; + otherRef->get_base()->get_qualifiers() = tq2; + } // if + } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) { + result = refType->clone(); + result->get_qualifiers() |= type2->get_qualifiers(); + } // if + } + void CommonType::visit( __attribute((unused)) FunctionType *functionType ) {} void CommonType::visit( __attribute((unused)) StructInstType *aggregateUseType ) {} @@ -203,8 +288,7 @@ if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) { // reuse BasicType, EnumInstType code by swapping type2 with enumInstType - Type * temp = type2; + ValueGuard< Type * > temp( type2 ); type2 = enumInstType; - temp->accept( *this ); - type2 = temp; + temp.old->accept( *this ); } // if } Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/ConversionCost.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -28,6 +28,16 @@ namespace ResolvExpr { - const Cost Cost::zero = Cost( 0, 0, 0 ); - const Cost Cost::infinity = Cost( -1, -1, -1 ); + const Cost Cost::zero = Cost( 0, 0, 0, 0 ); + const Cost Cost::infinity = Cost( -1, -1, -1, -1 ); + const Cost Cost::unsafe = Cost( 1, 0, 0, 0 ); + const Cost Cost::poly = Cost( 0, 1, 0, 0 ); + const Cost Cost::safe = Cost( 0, 0, 1, 0 ); + const Cost Cost::reference = Cost( 0, 0, 0, 1 ); + +#if 0 +#define PRINT(x) x +#else +#define PRINT(x) +#endif Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { @@ -35,5 +45,5 @@ EqvClass eqvClass; NamedTypeDecl *namedType; -/// std::cout << "type inst " << destAsTypeInst->get_name(); + PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); ) if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) { if ( eqvClass.type ) { @@ -43,25 +53,30 @@ } } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) { -/// std::cout << " found" << std::endl; + PRINT( std::cerr << " found" << std::endl; ) TypeDecl *type = dynamic_cast< TypeDecl* >( namedType ); // all typedefs should be gone by this point assert( type ); if ( type->get_base() ) { - return conversionCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 ); + return conversionCost( src, type->get_base(), indexer, env ) + Cost::safe; } // if } // if -/// std::cout << " not found" << std::endl; - } // if -/// std::cout << "src is "; -/// src->print( std::cout ); -/// std::cout << std::endl << "dest is "; -/// dest->print( std::cout ); -/// std::cout << std::endl << "env is" << std::endl; -/// env.print( std::cout, 8 ); + PRINT( std::cerr << " not found" << std::endl; ) + } // if + PRINT( + std::cerr << "src is "; + src->print( std::cerr ); + std::cerr << std::endl << "dest is "; + dest->print( std::cerr ); + std::cerr << std::endl << "env is" << std::endl; + env.print( std::cerr, 8 ); + ) if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) { -/// std::cout << "compatible!" << std::endl; - return Cost( 0, 0, 0 ); + PRINT( std::cerr << "compatible!" << std::endl; ) + return Cost::zero; } else if ( dynamic_cast< VoidType* >( dest ) ) { - return Cost( 0, 0, 1 ); + return Cost::safe; + } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) { + PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; ) + return convertToReferenceCost( src, refType, indexer, env ); } else { ConversionCost converter( dest, indexer, env ); @@ -70,7 +85,79 @@ return Cost::infinity; } else { - return converter.get_cost() + Cost( 0, 0, 0 ); - } // if - } // if + return converter.get_cost() + Cost::zero; + } // if + } // if + } + + Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) { + PRINT( std::cerr << "convert to reference cost..." << std::endl; ) + if ( diff > 0 ) { + // TODO: document this + Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env ); + cost.incReference(); + return cost; + } else if ( diff < -1 ) { + // TODO: document this + Cost cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env ); + cost.incReference(); + return cost; + } else if ( diff == 0 ) { + ReferenceType * srcAsRef = dynamic_cast< ReferenceType * >( src ); + ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest ); + if ( srcAsRef && destAsRef ) { // pointer-like conversions between references + PRINT( std::cerr << "converting between references" << std::endl; ) + if ( srcAsRef->get_base()->get_qualifiers() <= destAsRef->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) { + return Cost::safe; + } else { // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right? + int assignResult = ptrsAssignable( srcAsRef->get_base(), destAsRef->get_base(), env ); + PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; ) + if ( assignResult < 0 ) { + return Cost::safe; + } else if ( assignResult > 0 ) { + return Cost::unsafe; + } // if + } // if + } else { + PRINT( std::cerr << "reference to rvalue conversion" << std::endl; ) + ConversionCost converter( dest, indexer, env ); + src->accept( converter ); + return converter.get_cost(); + } // if + } else { + ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest ); + assert( diff == -1 && destAsRef ); + if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) { + PRINT( std::cerr << "converting compatible base type" << std::endl; ) + if ( src->get_lvalue() ) { + PRINT( + std::cerr << "lvalue to reference conversion" << std::endl; + std::cerr << src << " => " << destAsRef << std::endl; + ) + // lvalue-to-reference conversion: cv lvalue T => cv T & + if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) { + return Cost::reference; // cost needs to be non-zero to add cast + } if ( src->get_qualifiers() < destAsRef->get_base()->get_qualifiers() ) { + return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same + } else { + return Cost::unsafe; + } // if + } else if ( destAsRef->get_base()->get_const() ) { + PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; ) + // rvalue-to-const-reference conversion: T => const T & + return Cost::safe; + } else { + PRINT( std::cerr << "rvalue to non-const reference conversion" << std::endl; ) + // rvalue-to-reference conversion: T => T & + return Cost::unsafe; + } // if + } // if + PRINT( std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl; ) + } + return Cost::infinity; + } + + Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env ) { + int sdepth = src->referenceDepth(), ddepth = dest->referenceDepth(); + return convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env ); } @@ -164,13 +251,14 @@ int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ]; if ( tableResult == -1 ) { - cost = Cost( 1, 0, 0 ); - } else { - cost = Cost( 0, 0, tableResult ); + cost = Cost::unsafe; + } else { + cost = Cost::zero; + cost.incSafe( tableResult ); } // if } else if ( dynamic_cast< EnumInstType *>( dest ) ) { // xxx - not positive this is correct, but appears to allow casting int => enum - cost = Cost( 1, 0, 0 ); + cost = Cost::unsafe; } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) { - cost = Cost( 1, 0, 0 ); + cost = Cost::unsafe; } // if } @@ -178,20 +266,50 @@ void ConversionCost::visit(PointerType *pointerType) { if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) { - if ( pointerType->get_base()->get_qualifiers() <= destAsPtr->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) { - cost = Cost( 0, 0, 1 ); - } else { + PRINT( std::cerr << pointerType << " ===> " << destAsPtr; ) + Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers(); + Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers(); + if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) { + if ( tq1 == tq2 ) { + // types are the same + cost = Cost::zero; + } else { + // types are the same, except otherPointer has more qualifiers + PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; ) + cost = Cost::safe; + } + } else { // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right? int assignResult = ptrsAssignable( pointerType->get_base(), destAsPtr->get_base(), env ); - if ( assignResult < 0 ) { - cost = Cost( 0, 0, 1 ); + PRINT( std::cerr << " :: " << assignResult << std::endl; ) + if ( assignResult < 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) { + cost = Cost::safe; } else if ( assignResult > 0 ) { - cost = Cost( 1, 0, 0 ); + cost = Cost::unsafe; } // if + // assignResult == 0 means Cost::Infinity } // if } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) { - cost = Cost( 1, 0, 0 ); + cost = Cost::unsafe; } // if } void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {} + + void ConversionCost::visit(ReferenceType *refType) { + // Note: dest can never be a reference, since it would have been caught in an earlier check + assert( ! dynamic_cast< ReferenceType * >( dest ) ); + // convert reference to rvalue: cv T1 & => T2 + // recursively compute conversion cost from T1 to T2. + // cv can be safely dropped because of 'implicit dereference' behavior. + refType->get_base()->accept( *this ); + if ( refType->get_base()->get_qualifiers() == dest->get_qualifiers() ) { + cost.incReference(); // prefer exact qualifiers + } else if ( refType->get_base()->get_qualifiers() < dest->get_qualifiers() ) { + cost.incSafe(); // then gaining qualifiers + } else { + cost.incUnsafe(); // lose qualifiers as last resort + } + PRINT( std::cerr << refType << " ==> " << dest << " " << cost << std::endl; ) + } + void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {} @@ -215,6 +333,6 @@ static Type::Qualifiers q; static BasicType integer( q, BasicType::SignedInt ); - integer.accept( *this ); - if ( cost < Cost( 1, 0, 0 ) ) { + integer.accept( *this ); // safe if dest >= int + if ( cost < Cost::unsafe ) { cost.incSafe(); } // if @@ -238,5 +356,5 @@ assert( type ); if ( type->get_base() ) { - cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost( 0, 0, 1 ); + cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe; } // if } // if @@ -244,5 +362,5 @@ void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) { - Cost c; + Cost c = Cost::zero; if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) { std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin(); @@ -276,10 +394,11 @@ int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ]; if ( tableResult == -1 ) { - cost = Cost( 1, 0, 0 ); - } else { - cost = Cost( 0, 0, tableResult + 1 ); + cost = Cost::unsafe; + } else { + cost = Cost::zero; + cost.incSafe( tableResult + 1 ); } } else if ( dynamic_cast< PointerType* >( dest ) ) { - cost = Cost( 0, 0, 1 ); + cost = Cost::safe; } } @@ -292,7 +411,8 @@ int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ]; if ( tableResult == -1 ) { - cost = Cost( 1, 0, 0 ); - } else { - cost = Cost( 0, 0, tableResult + 1 ); + cost = Cost::unsafe; + } else { + cost = Cost::zero; + cost.incSafe( tableResult + 1 ); } } Index: src/ResolvExpr/ConversionCost.h =================================================================== --- src/ResolvExpr/ConversionCost.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/ConversionCost.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -37,4 +37,5 @@ virtual void visit(PointerType *pointerType); virtual void visit(ArrayType *arrayType); + virtual void visit(ReferenceType *refType); virtual void visit(FunctionType *functionType); virtual void visit(StructInstType *aggregateUseType); @@ -53,4 +54,6 @@ const TypeEnvironment &env; }; + + Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env ); } // namespace ResolvExpr Index: src/ResolvExpr/Cost.h =================================================================== --- src/ResolvExpr/Cost.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/Cost.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// Cost.h -- +// Cost.h -- // // Author : Richard C. Bilson @@ -20,12 +20,13 @@ namespace ResolvExpr { class Cost { + private: + Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost ); + public: - Cost(); - Cost( int unsafe, int poly, int safe ); - - void incUnsafe( int inc = 1 ); - void incPoly( int inc = 1 ); - void incSafe( int inc = 1 ); - + Cost & incUnsafe( int inc = 1 ); + Cost & incPoly( int inc = 1 ); + Cost & incSafe( int inc = 1 ); + Cost & incReference( int inc = 1 ); + Cost operator+( const Cost &other ) const; Cost operator-( const Cost &other ) const; @@ -35,70 +36,100 @@ bool operator!=( const Cost &other ) const; friend std::ostream &operator<<( std::ostream &os, const Cost &cost ); - + static const Cost zero; static const Cost infinity; + + static const Cost unsafe; + static const Cost poly; + static const Cost safe; + static const Cost reference; private: int compare( const Cost &other ) const; - int unsafe; - int poly; - int safe; + int unsafeCost; + int polyCost; + int safeCost; + int referenceCost; }; - inline Cost::Cost() : unsafe( 0 ), poly( 0 ), safe( 0 ) {} + inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost ) : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), referenceCost( referenceCost ) {} - inline Cost::Cost( int unsafe, int poly, int safe ) : unsafe( unsafe ), poly( poly ), safe( safe ) {} - - inline void Cost::incUnsafe( int inc ) { - unsafe += inc; + inline Cost & Cost::incUnsafe( int inc ) { + if ( *this == infinity ) return *this; + unsafeCost += inc; + return *this; } - inline void Cost::incPoly( int inc ) { - poly += inc; + inline Cost & Cost::incPoly( int inc ) { + if ( *this == infinity ) return *this; + polyCost += inc; + return *this; } - inline void Cost::incSafe( int inc ) { - safe += inc; + inline Cost & Cost::incSafe( int inc ) { + if ( *this == infinity ) return *this; + safeCost += inc; + return *this; + } + + inline Cost & Cost::incReference( int inc ) { + if ( *this == infinity ) return *this; + referenceCost += inc; + return *this; } inline Cost Cost::operator+( const Cost &other ) const { - return Cost( unsafe + other.unsafe, poly + other.poly, safe + other.safe ); + if ( *this == infinity || other == infinity ) return infinity; + return Cost( unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, referenceCost + other.referenceCost ); } inline Cost Cost::operator-( const Cost &other ) const { - return Cost( unsafe - other.unsafe, poly - other.poly, safe - other.safe ); + if ( *this == infinity || other == infinity ) return infinity; + return Cost( unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost, referenceCost - other.referenceCost ); } inline Cost &Cost::operator+=( const Cost &other ) { - unsafe += other.unsafe; - poly += other.poly; - safe += other.safe; + if ( *this == infinity ) return *this; + if ( other == infinity ) { + *this = infinity; + return *this; + } + unsafeCost += other.unsafeCost; + polyCost += other.polyCost; + safeCost += other.safeCost; + referenceCost += other.referenceCost; return *this; } inline bool Cost::operator<( const Cost &other ) const { - if ( *this == infinity ) return false; - if ( other == infinity ) return true; - if ( unsafe > other.unsafe ) { + if ( *this == infinity ) return false; + if ( other == infinity ) return true; + + if ( unsafeCost > other.unsafeCost ) { return false; - } else if ( unsafe < other.unsafe ) { + } else if ( unsafeCost < other.unsafeCost ) { return true; - } else if ( poly > other.poly ) { + } else if ( polyCost > other.polyCost ) { return false; - } else if ( poly < other.poly ) { + } else if ( polyCost < other.polyCost ) { return true; - } else if ( safe > other.safe ) { + } else if ( safeCost > other.safeCost ) { return false; - } else if ( safe < other.safe ) { + } else if ( safeCost < other.safeCost ) { return true; - } else { + } else if ( referenceCost > other.referenceCost ) { return false; - } // if + } else if ( referenceCost < other.referenceCost ) { + return true; + } else { + return false; + } // if } inline bool Cost::operator==( const Cost &other ) const { - return unsafe == other.unsafe - && poly == other.poly - && safe == other.safe; + return unsafeCost == other.unsafeCost + && polyCost == other.polyCost + && safeCost == other.safeCost + && referenceCost == other.referenceCost; } @@ -108,5 +139,5 @@ inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) { - os << "( " << cost.unsafe << ", " << cost.poly << ", " << cost.safe << " )"; + os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " << cost.safeCost << ", " << cost.referenceCost << " )"; return os; } Index: src/ResolvExpr/PtrsAssignable.cc =================================================================== --- src/ResolvExpr/PtrsAssignable.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/PtrsAssignable.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// PtrsAssignable.cc -- +// PtrsAssignable.cc -- // // Author : Richard C. Bilson @@ -82,8 +82,8 @@ void PtrsAssignable::visit( __attribute__((unused)) UnionInstType *inst ) {} - void PtrsAssignable::visit( EnumInstType *inst ) { - if ( dynamic_cast< EnumInstType* >( inst ) ) { + void PtrsAssignable::visit( EnumInstType * ) { + if ( dynamic_cast< EnumInstType* >( dest ) ) { result = 1; - } else if ( BasicType *bt = dynamic_cast< BasicType* >( inst ) ) { + } else if ( BasicType *bt = dynamic_cast< BasicType* >( dest ) ) { result = bt->get_kind() == BasicType::SignedInt; } @@ -104,5 +104,5 @@ void PtrsAssignable::visit( __attribute__((unused)) ZeroType *zeroType ) {} void PtrsAssignable::visit( __attribute__((unused)) OneType *oneType ) {} - + } // namespace ResolvExpr Index: src/ResolvExpr/ResolveTypeof.cc =================================================================== --- src/ResolvExpr/ResolveTypeof.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/ResolveTypeof.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -65,5 +65,7 @@ assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() ); Type *newType = newExpr->get_result(); + newExpr->set_result( nullptr ); delete typeofType; + delete newExpr; return newType; } // if Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/Unify.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -53,4 +53,5 @@ virtual void visit(PointerType *pointerType); virtual void visit(ArrayType *arrayType); + virtual void visit(ReferenceType *refType); virtual void visit(FunctionType *functionType); virtual void visit(StructInstType *aggregateUseType); @@ -153,4 +154,6 @@ bool bindVar( TypeInstType *typeInst, Type *other, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) { + // remove references from other, so that type variables can only bind to value types + other = other->stripReferences(); OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() ); assert( tyvar != openVars.end() ); @@ -387,4 +390,6 @@ } // if } else { + common = type1->clone(); + common->get_qualifiers() = tq1 | tq2; result = true; } // if @@ -436,4 +441,12 @@ markAssertions( haveAssertions, needAssertions, pointerType ); markAssertions( haveAssertions, needAssertions, otherPointer ); + } // if + } + + void Unify::visit(ReferenceType *refType) { + if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) { + result = unifyExact( refType->get_base(), otherRef->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); + markAssertions( haveAssertions, needAssertions, refType ); + markAssertions( haveAssertions, needAssertions, otherRef ); } // if } Index: src/ResolvExpr/typeops.h =================================================================== --- src/ResolvExpr/typeops.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/ResolvExpr/typeops.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -66,47 +66,6 @@ Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ); - template< typename SrcIterator, typename DestIterator > - Cost castCostList( SrcIterator srcBegin, SrcIterator srcEnd, DestIterator destBegin, DestIterator destEnd, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { - Cost ret; - if ( destBegin == destEnd ) { - if ( srcBegin == srcEnd ) { - return Cost::zero; - } else { - return Cost( 0, 0, 1 ); - } // if - } // if - while ( srcBegin != srcEnd && destBegin != destEnd ) { - Cost thisCost = castCost( *srcBegin++, *destBegin++, indexer, env ); - if ( thisCost == Cost::infinity ) { - return Cost::infinity; - } // if - ret += thisCost; - } // while - if ( srcBegin == srcEnd && destBegin == destEnd ) { - return ret; - } else { - return Cost::infinity; - } // if - } - // in ConversionCost.cc Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ); - - template< typename SrcIterator, typename DestIterator > - Cost conversionCostList( SrcIterator srcBegin, SrcIterator srcEnd, DestIterator destBegin, DestIterator destEnd, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { - Cost ret; - while ( srcBegin != srcEnd && destBegin != destEnd ) { - Cost thisCost = conversionCost( *srcBegin++, *destBegin++, indexer, env ); - if ( thisCost == Cost::infinity ) { - return Cost::infinity; - } // if - ret += thisCost; - } // while - if ( srcBegin == srcEnd && destBegin == destEnd ) { - return ret; - } else { - return Cost::infinity; - } // if - } // in PtrsAssignable.cc Index: src/SymTab/Autogen.cc =================================================================== --- src/SymTab/Autogen.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SymTab/Autogen.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -13,4 +13,5 @@ // Update Count : 62 // + #include "Autogen.h" @@ -24,13 +25,18 @@ #include // for vector -#include "AddVisit.h" // for addVisit -#include "Common/ScopedMap.h" // for ScopedMap -#include "GenPoly/DeclMutator.h" // for DeclMutator -#include "GenPoly/ScopedSet.h" // for ScopedSet -#include "Parser/LinkageSpec.h" // for AutoGen, Intrinsic, Spec -#include "SymTab/Mangler.h" // for mangleType -#include "SynTree/Statement.h" // for SwitchStmt (ptr only), CompoundStmt -#include "SynTree/Type.h" // for Type, ArrayType, Type::StorageClasses -#include "SynTree/Visitor.h" // for Visitor +#include "AddVisit.h" // for addVisit +#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign +#include "Common/ScopedMap.h" // for ScopedMap<>::const_iterator, Scope... +#include "Common/utility.h" // for cloneAll, operator+ +#include "GenPoly/DeclMutator.h" // for DeclMutator +#include "GenPoly/ScopedSet.h" // for ScopedSet, ScopedSet<>::iterator +#include "SymTab/Mangler.h" // for Mangler +#include "SynTree/Attribute.h" // For Attribute +#include "SynTree/Mutator.h" // for maybeMutate +#include "SynTree/Statement.h" // for CompoundStmt, ReturnStmt, ExprStmt +#include "SynTree/Type.h" // for FunctionType, Type, TypeInstType +#include "SynTree/Visitor.h" // for maybeAccept, Visitor, acceptAll + +class Attribute; namespace SymTab { @@ -130,5 +136,5 @@ FunctionType * genDefaultType( Type * paramType ) { FunctionType *ftype = new FunctionType( Type::Qualifiers(), false ); - ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr ); + ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr ); ftype->get_parameters().push_back( dstParam ); @@ -150,13 +156,4 @@ ftype->get_returnVals().push_back( returnVal ); return ftype; - } - - /// true if the aggregate's layout is dynamic - template< typename AggrDecl > - bool hasDynamicLayout( AggrDecl * aggregateDecl ) { - for ( TypeDecl * param : aggregateDecl->get_parameters() ) { - if ( param->isComplete() ) return true; - } - return false; } @@ -181,5 +178,6 @@ FunctionType * ftype = funcDecl->get_functionType(); assert( ! ftype->get_parameters().empty() ); - Type * t = safe_dynamic_cast< PointerType * >( ftype->get_parameters().front()->get_type() )->get_base(); + Type * t = InitTweak::getPointerBase( ftype->get_parameters().front()->get_type() ); + assert( t ); map.insert( Mangler::mangleType( t ), true ); } @@ -227,5 +225,5 @@ FunctionType * ftype = data.genType( refType ); - if(concurrent_type && InitTweak::isDestructor( data.fname )) { + if(concurrent_type && CodeGen::isDestructor( data.fname )) { ftype->get_parameters().front()->get_type()->set_mutex( true ); } @@ -279,4 +277,8 @@ FunctionType *copyCtorType = genCopyType( refType->clone() ); + // add unused attribute to parameters of default constructor and destructor + ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); + dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); + // xxx - should we also generate void ?{}(E *, int) and E ?{}(E *, E)? // right now these cases work, but that might change. @@ -301,27 +303,15 @@ /// generates a single struct member operation (constructor call, destructor call, assignment call) - void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool isDynamicLayout, bool forward = true ) { - ObjectDecl * returnVal = NULL; - if ( ! func->get_functionType()->get_returnVals().empty() ) { - returnVal = dynamic_cast( func->get_functionType()->get_returnVals().front() ); - } - + void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward = true ) { InitTweak::InitExpander srcParam( src ); - // assign to destination (and return value if generic) - UntypedExpr *derefExpr = UntypedExpr::createDeref( new VariableExpr( dstParam ) ); - Expression *dstselect = new MemberExpr( field, derefExpr ); + // assign to destination + Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), safe_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) ); genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward ); - - if ( isDynamicLayout && returnVal ) { - // xxx - there used to be a dereference on returnVal, but this seems to have been wrong? - Expression *retselect = new MemberExpr( field, new VariableExpr( returnVal ) ); - genImplicitCall( srcParam, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward ); - } // if } /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies template - void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool isDynamicLayout, bool forward = true ) { + void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true ) { for ( ; member != end; ++member ) { if ( DeclarationWithType *field = dynamic_cast< DeclarationWithType * >( *member ) ) { // otherwise some form of type declaration, e.g. Aggregate @@ -359,5 +349,5 @@ Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL; - makeStructMemberOp( dstParam, srcselect, field, func, isDynamicLayout, forward ); + makeStructMemberOp( dstParam, srcselect, field, func, forward ); } // if } // for @@ -367,5 +357,5 @@ /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields. template - void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func, bool isDynamicLayout ) { + void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ) { FunctionType * ftype = func->get_functionType(); std::list & params = ftype->get_parameters(); @@ -393,9 +383,9 @@ // matching parameter, initialize field with copy ctor Expression *srcselect = new VariableExpr(*parameter); - makeStructMemberOp( dstParam, srcselect, field, func, isDynamicLayout ); + makeStructMemberOp( dstParam, srcselect, field, func ); ++parameter; } else { // no matching parameter, initialize field with default ctor - makeStructMemberOp( dstParam, NULL, field, func, isDynamicLayout ); + makeStructMemberOp( dstParam, NULL, field, func ); } } @@ -413,5 +403,4 @@ // Make function polymorphic in same parameters as generic struct, if applicable const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions - bool isDynamicLayout = hasDynamicLayout( aggregateDecl ); // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for union) // generate each of the functions based on the supplied FuncData objects @@ -423,5 +412,5 @@ // field ctors are only generated if default constructor and copy constructor are both generated - unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return InitTweak::isConstructor( dcl->get_name() ); } ); + unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return CodeGen::isConstructor( dcl->get_name() ); } ); if ( functionNesting == 0 ) { @@ -438,10 +427,10 @@ // generate appropriate calls to member ctor, assignment // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor - if ( ! InitTweak::isDestructor( dcl->get_name() ) ) { - makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), dcl, isDynamicLayout ); + if ( ! CodeGen::isDestructor( dcl->get_name() ) ) { + makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), dcl ); } else { - makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dcl, isDynamicLayout, false ); - } - if ( InitTweak::isAssignment( dcl->get_name() ) ) { + makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dcl, false ); + } + if ( CodeGen::isAssignment( dcl->get_name() ) ) { // assignment needs to return a value FunctionType * assignType = dcl->get_functionType(); @@ -472,12 +461,10 @@ // our inheritance model. I think the correct way to handle this is to // cast the structure to the type of the member and let the resolver - // figure out whether it's valid and have a pass afterwards that fixes - // the assignment to use pointer arithmetic with the offset of the - // member, much like how generic type members are handled. + // figure out whether it's valid/choose the correct unnamed member continue; } memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) ); FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting ); - makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor, isDynamicLayout ); + makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor ); declsToAdd.push_back( ctor ); } @@ -490,5 +477,5 @@ void makeUnionFieldsAssignment( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) { UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) ); - copy->get_args().push_back( new VariableExpr( dstParam ) ); + copy->get_args().push_back( new AddressExpr( new VariableExpr( dstParam ) ) ); copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) ); copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) ); @@ -502,11 +489,8 @@ ObjectDecl * dstParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() ); ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() ); - ObjectDecl * returnVal = nullptr; - if ( ! ftype->get_returnVals().empty() ) { - returnVal = safe_dynamic_cast< ObjectDecl * >( ftype->get_returnVals().front() ); - } makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) ); - if ( returnVal ) { + if ( CodeGen::isAssignment( funcDecl->get_name() ) ) { + // also generate return statement in assignment funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) ); } @@ -535,4 +519,8 @@ cloneAll( typeParams, copyCtorType->get_forall() ); cloneAll( typeParams, assignType->get_forall() ); + + // add unused attribute to parameters of default constructor and destructor + ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); + dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); // Routines at global scope marked "static" to prevent multiple definitions is separate translation units Index: src/SymTab/Autogen.h =================================================================== --- src/SymTab/Autogen.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SymTab/Autogen.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -40,4 +40,11 @@ extern Type * SizeType; + /// intrinsic dereference operator for unqualified types - set when *? function is seen in FindSpecialDeclarations. + /// Useful for creating dereference ApplicationExprs without a full resolver pass. + extern FunctionDecl * dereferenceOperator; + + // temporary + FunctionType * genAssignType( Type * paramType ); + /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. template< typename OutputIterator > @@ -48,35 +55,33 @@ 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(); - 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 ); + 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( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic ); + // castType->set_lvalue( true ); // xxx - might not need this + dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) ); + } + 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; } @@ -114,5 +119,5 @@ UntypedExpr *inc = new UntypedExpr( update ); - inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) ); + inc->get_args().push_back( new VariableExpr( index ) ); UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) ); Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SymTab/Indexer.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -23,4 +23,5 @@ #include // for pair, make_pair, move +#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign #include "Common/SemanticError.h" // for SemanticError #include "Common/utility.h" // for cloneAll @@ -111,5 +112,5 @@ void Indexer::removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const { // only need to perform this step for constructors, destructors, and assignment functions - if ( ! InitTweak::isCtorDtorAssign( id ) ) return; + if ( ! CodeGen::isCtorDtorAssign( id ) ) return; // helpful data structure @@ -139,5 +140,5 @@ decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } ); existsUserDefinedFunc = existsUserDefinedFunc || isUserDefinedFunc; - existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && InitTweak::isConstructor( function->get_name() ) ); + existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && CodeGen::isConstructor( function->get_name() ) ); existsUserDefinedDtor = existsUserDefinedDtor || (isUserDefinedFunc && isDtor); existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc); @@ -157,5 +158,6 @@ assert( ! params.empty() ); // use base type of pointer, so that qualifiers on the pointer type aren't considered. - Type * base = safe_dynamic_cast< PointerType * >( params.front()->get_type() )->get_base(); + Type * base = InitTweak::getPointerBase( params.front()->get_type() ); + assert( base ); funcMap[ Mangler::mangle( base ) ] += function; } else { Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SymTab/Mangler.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -132,4 +132,10 @@ mangleName << "A0"; maybeAccept( arrayType->get_base(), *this ); + } + + void Mangler::visit( ReferenceType *refType ) { + printQualifiers( refType ); + mangleName << "R"; + maybeAccept( refType->get_base(), *this ); } @@ -303,5 +309,5 @@ // Removed due to restrict not affecting function compatibility in GCC // if ( type->get_isRestrict() ) { -// mangleName << "R"; +// mangleName << "E"; // } // if if ( type->get_lvalue() ) { Index: src/SymTab/Mangler.h =================================================================== --- src/SymTab/Mangler.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SymTab/Mangler.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -42,4 +42,5 @@ virtual void visit( PointerType *pointerType ); virtual void visit( ArrayType *arrayType ); + virtual void visit( ReferenceType *refType ); virtual void visit( FunctionType *functionType ); virtual void visit( StructInstType *aggregateUseType ); Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SymTab/Validate.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -47,4 +47,5 @@ #include "CodeGen/CodeGenerator.h" // for genName +#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign #include "Common/PassVisitor.h" // for PassVisitor, WithDeclsToAdd #include "Common/ScopedMap.h" // for ScopedMap @@ -239,4 +240,10 @@ }; + + FunctionDecl * dereferenceOperator = nullptr; + struct FindSpecialDeclarations final { + void previsit( FunctionDecl * funcDecl ); + }; + void validate( std::list< Declaration * > &translationUnit, bool doDebug ) { PassVisitor epc; @@ -245,4 +252,5 @@ PassVisitor compoundliteral; PassVisitor genericParams; + PassVisitor finder; EliminateTypedef::eliminateTypedef( translationUnit ); @@ -261,4 +269,5 @@ acceptAll( translationUnit, fpd ); ArrayLength::computeLength( translationUnit ); + acceptAll( translationUnit, finder ); } @@ -821,13 +830,13 @@ std::list< DeclarationWithType * > ¶ms = funcType->get_parameters(); - if ( InitTweak::isCtorDtorAssign( funcDecl->get_name() ) ) { + if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc. if ( params.size() == 0 ) { throw SemanticError( "Constructors, destructors, and assignment functions require at least one parameter ", funcDecl ); } - PointerType * ptrType = dynamic_cast< PointerType * >( params.front()->get_type() ); - if ( ! ptrType || ptrType->is_array() ) { - throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a pointer ", funcDecl ); + ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() ); + if ( ! refType ) { + throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a reference ", funcDecl ); } - if ( InitTweak::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) { + if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) { throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl ); } @@ -945,4 +954,15 @@ } } + + void FindSpecialDeclarations::previsit( FunctionDecl * funcDecl ) { + if ( ! dereferenceOperator ) { + if ( funcDecl->get_name() == "*?" && funcDecl->get_linkage() == LinkageSpec::Intrinsic ) { + FunctionType * ftype = funcDecl->get_functionType(); + if ( ftype->get_parameters().size() == 1 && ftype->get_parameters().front()->get_type()->get_qualifiers() == Type::Qualifiers() ) { + dereferenceOperator = funcDecl; + } + } + } + } } // namespace SymTab Index: src/SynTree/AddressExpr.cc =================================================================== --- src/SynTree/AddressExpr.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/AddressExpr.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -21,7 +21,35 @@ #include "Type.h" // for PointerType, Type, Type::Qualifiers +// Address expressions are typed based on the following inference rules: +// E : lvalue T &..& (n references) +// &E : T *&..& (n references) +// +// E : T &..& (m references) +// &E : T *&..& (m-1 references) +// +// That is, lvalues becomes + +namespace { + Type * addrType( Type * type ) { + if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) { + return new ReferenceType( refType->get_qualifiers(), addrType( refType->get_base() ) ); + } else { + return new PointerType( Type::Qualifiers(), type->clone() ); + } + } +} + AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) { if ( arg->has_result() ) { - set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) ); + if ( arg->get_result()->get_lvalue() ) { + // lvalue, retains all layers of reference and gains a pointer inside the references + set_result( addrType( arg->get_result() ) ); + } else { + // taking address of non-lvalue -- must be a reference, loses one layer of reference + ReferenceType * refType = safe_dynamic_cast< ReferenceType * >( arg->get_result() ); + set_result( addrType( refType->get_base() ) ); + } + // result of & is never an lvalue + get_result()->set_lvalue( false ); } } Index: src/SynTree/ApplicationExpr.cc =================================================================== --- src/SynTree/ApplicationExpr.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/ApplicationExpr.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -49,5 +49,5 @@ } -ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list< Expression * > & argList ) : function( funcExpr ), args( argList ) { +ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list & args ) : function( funcExpr ), args( args ) { PointerType *pointer = safe_dynamic_cast< PointerType* >( funcExpr->get_result() ); FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() ); Index: src/SynTree/Declaration.h =================================================================== --- src/SynTree/Declaration.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/Declaration.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -109,5 +109,5 @@ virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0; - virtual Type *get_type() const = 0; + virtual Type * get_type() const = 0; virtual void set_type(Type *) = 0; @@ -128,5 +128,5 @@ virtual ~ObjectDecl(); - virtual Type *get_type() const { return type; } + virtual Type * get_type() const { return type; } virtual void set_type(Type *newType) { type = newType; } @@ -155,8 +155,8 @@ virtual ~FunctionDecl(); - Type *get_type() const; + Type * get_type() const; virtual void set_type(Type *); - FunctionType *get_functionType() const { return type; } + FunctionType * get_functionType() const { return type; } void set_functionType( FunctionType *newValue ) { type = newValue; } CompoundStmt *get_statements() const { return statements; } Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/Expression.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -31,4 +31,5 @@ #include "TypeSubstitution.h" // for TypeSubstitution +#include "GenPoly/Lvalue.h" Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {} @@ -89,4 +90,10 @@ } +VariableExpr * VariableExpr::functionPointer( FunctionDecl * func ) { + VariableExpr * funcExpr = new VariableExpr( func ); + funcExpr->set_result( new PointerType( Type::Qualifiers(), funcExpr->get_result() ) ); + return funcExpr; +} + void VariableExpr::print( std::ostream &os, int indent ) const { os << "Variable Expression: "; @@ -149,5 +156,5 @@ void AlignofExpr::print( std::ostream &os, int indent) const { - os << std::string( indent, ' ' ) << "Alignof Expression on: "; + os << "Alignof Expression on: "; if (isType) @@ -258,5 +265,5 @@ void AttrExpr::print( std::ostream &os, int indent) const { - os << std::string( indent, ' ' ) << "Attr "; + os << "Attr "; attr->print( os, indent + 2 ); if ( isType || expr ) { @@ -357,5 +364,7 @@ namespace { TypeSubstitution makeSub( Type * t ) { - if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) { + if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( t ) ) { + return makeSub( refType->get_base() ); + } else if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) { return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() ); } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) { @@ -422,9 +431,13 @@ if ( Type * type = expr->get_result() ) { Type * base = InitTweak::getPointerBase( type ); - if ( ! base ) { - std::cerr << type << std::endl; + assertf( base, "expected pointer type in dereference (type was %s)", toString( type ).c_str() ); + ret->set_result( base->clone() ); + if ( GenPoly::referencesPermissable() ) { + // if references are still allowed in the AST, dereference returns a reference + ret->set_result( new ReferenceType( Type::Qualifiers(), ret->get_result() ) ); + } else { + // references have been removed, in which case dereference returns an lvalue of the base type. + ret->get_result()->set_lvalue( true ); } - assertf( base, "expected pointer type in dereference\n" ); - ret->set_result( maybeClone( base ) ); } return ret; @@ -490,5 +503,5 @@ void LogicalExpr::print( std::ostream &os, int indent )const { - os << std::string( indent, ' ' ) << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: "; + os << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: "; arg1->print(os); os << " and "; @@ -595,4 +608,5 @@ CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) { assert( type && initializer ); + type->set_lvalue( true ); set_result( type ); } Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/Expression.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -284,4 +284,6 @@ void set_var( DeclarationWithType * newValue ) { var = newValue; } + static VariableExpr * functionPointer( FunctionDecl * decl ); + virtual VariableExpr * clone() const { return new VariableExpr( * this ); } virtual void accept( Visitor & v ) { v.visit( this ); } Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/Mutator.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -484,4 +484,10 @@ } +Type *Mutator::mutate( ReferenceType *refType ) { + mutateAll( refType->get_forall(), *this ); + refType->set_base( maybeMutate( refType->get_base(), *this ) ); + return refType; +} + Type *Mutator::mutate( FunctionType *functionType ) { mutateAll( functionType->get_forall(), *this ); Index: src/SynTree/Mutator.h =================================================================== --- src/SynTree/Mutator.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/Mutator.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -92,4 +92,5 @@ virtual Type* mutate( PointerType *pointerType ); virtual Type* mutate( ArrayType *arrayType ); + virtual Type* mutate( ReferenceType *refType ); virtual Type* mutate( FunctionType *functionType ); virtual Type* mutate( StructInstType *aggregateUseType ); Index: src/SynTree/ReferenceType.cc =================================================================== --- src/SynTree/ReferenceType.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) +++ src/SynTree/ReferenceType.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -0,0 +1,49 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// PointerType.cc -- +// +// Author : Rob Schluntz +// Created On : Fri May 12 18:12:15 2017 +// Last Modified By : Rob Schluntz +// Last Modified On : Fri May 12 18:12:15 2017 +// Update Count : 1 +// + +#include "Type.h" +#include "Expression.h" +#include "Common/utility.h" + +ReferenceType::ReferenceType( const Type::Qualifiers &tq, Type *base, const std::list< Attribute * > & attributes ) + : Type( tq, attributes ), base( base ) { + assertf( base, "Reference Type with a null base created." ); +} + +ReferenceType::ReferenceType( const ReferenceType &other ) + : Type( other ), base( maybeClone( other.base ) ) { +} + +ReferenceType::~ReferenceType() { + delete base; +} + +int ReferenceType::referenceDepth() const { + return base->referenceDepth()+1; +} + +void ReferenceType::print( std::ostream &os, int indent ) const { + Type::print( os, indent ); + os << "reference to "; + if ( base ) { + base->print( os, indent ); + } // if +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/SynTree/SynTree.h =================================================================== --- src/SynTree/SynTree.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/SynTree.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -101,4 +101,5 @@ class PointerType; class ArrayType; +class ReferenceType; class FunctionType; class ReferenceToType; Index: src/SynTree/TupleExpr.cc =================================================================== --- src/SynTree/TupleExpr.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/TupleExpr.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -67,5 +67,6 @@ assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() ); set_result( (*std::next( type->get_types().begin(), index ))->clone() ); - get_result()->set_lvalue( type->get_lvalue() ); + // like MemberExpr, TupleIndexExpr is always an lvalue + get_result()->set_lvalue( true ); } Index: src/SynTree/Type.cc =================================================================== --- src/SynTree/Type.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/Type.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -64,5 +64,5 @@ const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" }; -Type *Type::stripDeclarator() { +Type * Type::stripDeclarator() { Type * type = this; while ( Type * at = InitTweak::getPointerBase( type ) ) { @@ -71,4 +71,14 @@ return type; } + +Type * Type::stripReferences() { + Type * type = this; + while ( ReferenceType * ref = dynamic_cast( type ) ) { + type = ref->get_base(); + } + return type; +} + +int Type::referenceDepth() const { return 0; } void Type::print( std::ostream &os, int indent ) const { Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/Type.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -168,5 +168,11 @@ /// return type without outer pointers and arrays - Type *stripDeclarator(); + Type * stripDeclarator(); + + /// return type without outer references + Type * stripReferences(); + + /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types) + virtual int referenceDepth() const; virtual bool isComplete() const { return true; } @@ -262,4 +268,6 @@ bool is_array() const { return isStatic || isVarLen || dimension; } + virtual bool isComplete() const { return ! isVarLen; } + virtual PointerType *clone() const { return new PointerType( *this ); } virtual void accept( Visitor & v ) { v.visit( this ); } @@ -296,4 +304,28 @@ }; +class ReferenceType : public Type { +public: + Type *base; + + ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + ReferenceType( const ReferenceType & ); + virtual ~ReferenceType(); + + Type *get_base() { return base; } + void set_base( Type *newValue ) { base = newValue; } + + virtual int referenceDepth() const; + + // Since reference types act like value types, their size is the size of the base. + // This makes it simple to cast the empty tuple to a reference type, since casts that increase + // the number of values are disallowed. + virtual unsigned size() const { return base->size(); } + + virtual ReferenceType *clone() const { return new ReferenceType( *this ); } + virtual void accept( Visitor & v ) { v.visit( this ); } + virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); } + virtual void print( std::ostream & os, int indent = 0 ) const; +}; + class FunctionType : public Type { public: Index: src/SynTree/TypeExpr.cc =================================================================== --- src/SynTree/TypeExpr.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/TypeExpr.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// TypeExpr.cc -- +// TypeExpr.cc -- // // Author : Richard C. Bilson Index: src/SynTree/TypeSubstitution.h =================================================================== --- src/SynTree/TypeSubstitution.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/TypeSubstitution.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -117,5 +117,5 @@ } // if } else { - throw SemanticError( "Attempt to provide non-type parameter for type parameter", formal ); + throw SemanticError( toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ), formal ); } // if } else { Index: src/SynTree/Visitor.cc =================================================================== --- src/SynTree/Visitor.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/Visitor.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -373,4 +373,5 @@ void Visitor::visit( PointerType *pointerType ) { acceptAll( pointerType->get_forall(), *this ); + // xxx - should PointerType visit/mutate dimension? maybeAccept( pointerType->get_base(), *this ); } @@ -380,4 +381,9 @@ maybeAccept( arrayType->get_dimension(), *this ); maybeAccept( arrayType->get_base(), *this ); +} + +void Visitor::visit( ReferenceType *refType ) { + acceptAll( refType->get_forall(), *this ); + maybeAccept( refType->get_base(), *this ); } Index: src/SynTree/Visitor.h =================================================================== --- src/SynTree/Visitor.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/Visitor.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -94,4 +94,5 @@ virtual void visit( PointerType *pointerType ); virtual void visit( ArrayType *arrayType ); + virtual void visit( ReferenceType *refType ); virtual void visit( FunctionType *functionType ); virtual void visit( StructInstType *aggregateUseType ); Index: src/SynTree/module.mk =================================================================== --- src/SynTree/module.mk (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/SynTree/module.mk (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -20,4 +20,5 @@ SynTree/PointerType.cc \ SynTree/ArrayType.cc \ + SynTree/ReferenceType.cc \ SynTree/FunctionType.cc \ SynTree/ReferenceToType.cc \ Index: src/Tuples/Explode.cc =================================================================== --- src/Tuples/Explode.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Tuples/Explode.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -15,54 +15,78 @@ #include "Explode.h" +#include // for list -#include // for list - -#include "SynTree/Mutator.h" // for Mutator +#include "SynTree/Mutator.h" // for Mutator +#include "Common/PassVisitor.h" // for PassVisitor namespace Tuples { namespace { - struct AddrExploder : public Mutator { + // remove one level of reference from a reference type -- may be useful elsewhere. + Type * getReferenceBase( Type * t ) { + if ( ReferenceType * refType = dynamic_cast( t ) ) { + return refType->get_base(); + } else { + // for the moment, I want to know immediately if a non-reference type is ever passed in here. + assertf( false, "getReferenceBase for non-ref: %s", toString( refType ).c_str() ); + return nullptr; + } + } + + struct CastExploder { + bool castAdded = false; bool foundUniqueExpr = false; - Expression * applyAddr( Expression * expr, bool first = true ) { + Expression * applyCast( Expression * expr, bool first = true ) { if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ){ foundUniqueExpr = true; std::list< Expression * > exprs; for ( Expression *& expr : tupleExpr->get_exprs() ) { - // move & into tuple exprs - exprs.push_back( applyAddr( expr, false ) ); + // move cast into tuple exprs + exprs.push_back( applyCast( expr, false ) ); } - // want the top-level expression to be address-taken, but not nested + // want the top-level expression to be cast to reference type, but not nested // tuple expressions if ( first ) { - return new AddressExpr( new TupleExpr( exprs ) ); + castAdded = true; + Expression * tupleExpr = new TupleExpr( exprs ); + return new CastExpr( tupleExpr, new ReferenceType( Type::Qualifiers(), tupleExpr->result->clone() ) ); } else { return new TupleExpr( exprs ); } } - // anything else should be address-taken as normal - return new AddressExpr( expr->clone() ); + if ( dynamic_cast( expr->result ) ) { + // don't need to cast reference type to another reference type + return expr->clone(); + } else { + // anything else should be cast to reference as normal + castAdded = true; + return new CastExpr( expr->clone(), new ReferenceType( Type::Qualifiers(), expr->result->clone() ) ); + } } - virtual Expression * mutate( UniqueExpr * uniqueExpr ) { - // move & into unique expr so that the unique expr has type T* rather than + Expression * postmutate( UniqueExpr * uniqueExpr ) { + // move cast into unique expr so that the unique expr has type T& rather than // type T. In particular, this transformation helps with generating the - // correct code for address-taken member tuple expressions, since the result - // should now be a tuple of addresses rather than the address of a tuple. + // correct code for reference-cast member tuple expressions, since the result + // should now be a tuple of references rather than a reference to a tuple. // Still, this code is a bit awkward, and could use some improvement. - if ( dynamic_cast< AddressExpr * > ( uniqueExpr->get_expr() ) ) { - // this unique expression has already been mutated or otherwise shouldn't be (can't take the address-of an address-of expression) - return uniqueExpr; + UniqueExpr * newUniqueExpr = new UniqueExpr( applyCast( uniqueExpr->get_expr() ), uniqueExpr->get_id() ); + delete uniqueExpr; + if ( castAdded ) { + // if a cast was added by applyCast, then unique expr now has one more layer of reference + // than it had coming into this function. To ensure types still match correctly, need to cast + // to reference base so that outer expressions are still correct. + castAdded = false; + Type * toType = getReferenceBase( newUniqueExpr->result ); + return new CastExpr( newUniqueExpr, toType->clone() ); } - UniqueExpr * newUniqueExpr = new UniqueExpr( applyAddr( uniqueExpr->get_expr() ), uniqueExpr->get_id() ); - delete uniqueExpr; - UntypedExpr * deref = UntypedExpr::createDeref( Mutator::mutate( newUniqueExpr ) ); - return deref; + return newUniqueExpr; } - virtual Expression * mutate( TupleIndexExpr * tupleExpr ) { + + Expression * postmutate( TupleIndexExpr * tupleExpr ) { // tuple index expr needs to be rebuilt to ensure that the type of the // field is consistent with the type of the tuple expr, since the field - // may have changed from type T to T*. - Expression * expr = tupleExpr->get_tuple()->acceptMutator( *this ); + // may have changed from type T to T&. + Expression * expr = tupleExpr->get_tuple(); tupleExpr->set_tuple( nullptr ); TupleIndexExpr * ret = new TupleIndexExpr( expr, tupleExpr->get_index() ); @@ -73,9 +97,10 @@ } // namespace - Expression * distributeAddr( Expression * expr ) { - AddrExploder addrExploder; - expr = expr->acceptMutator( addrExploder ); - if ( ! addrExploder.foundUniqueExpr ) { - expr = new AddressExpr( expr ); + Expression * distributeReference( Expression * expr ) { + PassVisitor exploder; + expr = expr->acceptMutator( exploder ); + if ( ! exploder.pass.foundUniqueExpr ) { + // if a UniqueExpr was found, then the cast has already been added inside the UniqueExpr as appropriate + expr = new CastExpr( expr, new ReferenceType( Type::Qualifiers(), expr->result->clone() ) ); } return expr; Index: src/Tuples/Explode.h =================================================================== --- src/Tuples/Explode.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Tuples/Explode.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -28,7 +28,5 @@ namespace Tuples { - /// helper function used by explode to properly distribute - /// '&' across a tuple expression - Expression * distributeAddr( Expression * expr ); + Expression * distributeReference( Expression * ); /// helper function used by explode @@ -36,11 +34,11 @@ void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign ) { if ( isTupleAssign ) { - // tuple assignment needs AddressExprs to be recursively exploded to easily get at all of the components - if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) { + // tuple assignment needs CastExprs to be recursively exploded to easily get at all of the components + if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { ResolvExpr::AltList alts; - explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign ); + explodeUnique( castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign ); for ( ResolvExpr::Alternative & alt : alts ) { - // distribute '&' over all components - alt.expr = distributeAddr( alt.expr ); + // distribute reference cast over all components + alt.expr = distributeReference( alt.expr ); *out++ = alt; } @@ -49,5 +47,5 @@ } } - Type * res = expr->get_result(); + Type * res = expr->get_result()->stripReferences(); if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) { if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ) { @@ -57,9 +55,14 @@ } } else { - // tuple type, but not tuple expr - recursively index into its components + // tuple type, but not tuple expr - recursively index into its components. + // if expr type is reference, convert to value type Expression * arg = expr->clone(); - if ( Tuples::maybeImpure( arg ) && ! dynamic_cast< UniqueExpr * >( arg ) ) { + if ( Tuples::maybeImpureIgnoreUnique( arg ) ) { // expressions which may contain side effects require a single unique instance of the expression. arg = new UniqueExpr( arg ); + } + // cast reference to value type to facilitate further explosion + if ( dynamic_cast( arg->get_result() ) ) { + arg = new CastExpr( arg, tupleType->clone() ); } for ( unsigned int i = 0; i < tupleType->size(); i++ ) { Index: src/Tuples/TupleAssignment.cc =================================================================== --- src/Tuples/TupleAssignment.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Tuples/TupleAssignment.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -21,4 +21,5 @@ #include // for string +#include "CodeGen/OperatorTable.h" #include "Common/UniqueName.h" // for UniqueName #include "Common/utility.h" // for zipWith @@ -84,5 +85,5 @@ if ( ! expr ) return false; assert( expr->has_result() ); - return dynamic_cast< TupleType * >( expr->get_result() ); + return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() ); } @@ -96,10 +97,11 @@ } - bool pointsToTuple( Expression *expr ) { + bool refToTuple( Expression *expr ) { + assert( expr->get_result() ); // also check for function returning tuple of reference types if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { - return pointsToTuple( castExpr->get_arg() ); - } else if ( AddressExpr *addr = dynamic_cast< AddressExpr * >( expr) ) { - return isTuple( addr->get_arg() ); + return refToTuple( castExpr->get_arg() ); + } else { + return isTuple( expr ); } return false; @@ -116,9 +118,9 @@ void TupleAssignSpotter::spot( UntypedExpr * expr, const std::list &possibilities ) { if ( NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) { - if ( InitTweak::isCtorDtorAssign( op->get_name() ) ) { + if ( CodeGen::isCtorDtorAssign( op->get_name() ) ) { fname = op->get_name(); for ( std::list::const_iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) { if ( ali->size() == 0 ) continue; // AlternativeFinder will natrually handle this case, if it's legal - if ( ali->size() <= 1 && InitTweak::isAssignment( op->get_name() ) ) { + if ( ali->size() <= 1 && CodeGen::isAssignment( op->get_name() ) ) { // what does it mean if an assignment takes 1 argument? maybe someone defined such a function, in which case AlternativeFinder will naturally handle it continue; @@ -129,5 +131,5 @@ const ResolvExpr::Alternative & alt1 = ali->front(); auto begin = std::next(ali->begin(), 1), end = ali->end(); - if ( pointsToTuple(alt1.expr) ) { + if ( refToTuple(alt1.expr) ) { if ( isMultAssign( begin, end ) ) { matcher.reset( new MultipleAssignMatcher( *this, *ali ) ); @@ -187,11 +189,7 @@ ResolvExpr::Alternative lhsAlt = alts.front(); - // peel off the cast that exists on ctor/dtor expressions - bool isCast = false; - if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( lhsAlt.expr ) ) { - lhsAlt.expr = castExpr->get_arg(); - castExpr->set_arg( nullptr ); - delete castExpr; - isCast = true; + // explode is aware of casts - ensure every LHS expression is sent into explode with a reference cast + if ( ! dynamic_cast< CastExpr * >( lhsAlt.expr ) ) { + lhsAlt.expr = new CastExpr( lhsAlt.expr, new ReferenceType( Type::Qualifiers(), lhsAlt.expr->get_result()->clone() ) ); } @@ -199,14 +197,8 @@ explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs), true ); - // and finally, re-add the cast to each lhs expr, so that qualified tuple fields can be constructed - if ( isCast ) { - for ( ResolvExpr::Alternative & alt : lhs ) { - Expression *& expr = alt.expr; - Type * castType = expr->get_result()->clone(); - Type * type = InitTweak::getPointerBase( castType ); - assert( type ); - type->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic ); - type->set_lvalue( true ); // xxx - might not need this - expr = new CastExpr( expr, castType ); + for ( ResolvExpr::Alternative & alt : lhs ) { + // every LHS value must be a reference - some come in with a cast expression, if it doesn't just cast to reference here. + if ( ! dynamic_cast< ReferenceType * >( alt.expr->get_result() ) ) { + alt.expr = new CastExpr( alt.expr, new ReferenceType( Type::Qualifiers(), alt.expr->get_result()->clone() ) ); } } @@ -228,5 +220,5 @@ assert( left ); std::list< Expression * > args; - args.push_back( new AddressExpr( UntypedExpr::createDeref( new VariableExpr( left ) ) ) ); + args.push_back( new VariableExpr( left ) ); // args.push_back( new AddressExpr( new VariableExpr( left ) ) ); if ( right ) args.push_back( new VariableExpr( right ) ); @@ -248,9 +240,12 @@ assert( expr->has_result() && ! expr->get_result()->isVoid() ); ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) ); - ConstructorInit * ctorInit = InitTweak::genCtorInit( ret ); - ret->set_init( ctorInit ); - ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object - EnvRemover rm; // remove environments from subexpressions of StmtExprs - ctorInit->accept( rm ); + // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient. + if ( ! dynamic_cast< ReferenceType * >( expr->get_result() ) ) { + ConstructorInit * ctorInit = InitTweak::genCtorInit( ret ); + ret->set_init( ctorInit ); + ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object + EnvRemover rm; // remove environments from subexpressions of StmtExprs + ctorInit->accept( rm ); + } return ret; } Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Tuples/TupleExpansion.cc (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -37,6 +37,5 @@ namespace Tuples { namespace { - class MemberTupleExpander final : public Mutator { - public: + struct MemberTupleExpander final : public Mutator { typedef Mutator Parent; using Parent::mutate; @@ -45,10 +44,6 @@ }; - class UniqueExprExpander final : public GenPoly::DeclMutator { - public: - typedef GenPoly::DeclMutator Parent; - using Parent::mutate; - - virtual Expression * mutate( UniqueExpr * unqExpr ) override; + struct UniqueExprExpander final : public WithDeclsToAdd { + Expression * postmutate( UniqueExpr * unqExpr ); std::map< int, Expression * > decls; // not vector, because order added may not be increasing order @@ -61,10 +56,6 @@ }; - class TupleAssignExpander : public Mutator { - public: - typedef Mutator Parent; - using Parent::mutate; - - virtual Expression * mutate( TupleAssignExpr * tupleExpr ); + struct TupleAssignExpander { + Expression * postmutate( TupleAssignExpr * tupleExpr ); }; @@ -79,15 +70,10 @@ }; - class TupleIndexExpander { - public: + struct TupleIndexExpander { Expression * postmutate( TupleIndexExpr * tupleExpr ); }; - class TupleExprExpander final : public Mutator { - public: - typedef Mutator Parent; - using Parent::mutate; - - virtual Expression * mutate( TupleExpr * tupleExpr ) override; + struct TupleExprExpander final { + Expression * postmutate( TupleExpr * tupleExpr ); }; } @@ -99,10 +85,10 @@ void expandUniqueExpr( std::list< Declaration * > & translationUnit ) { - UniqueExprExpander unqExpander; - unqExpander.mutateDeclarationList( translationUnit ); + PassVisitor unqExpander; + mutateAll( translationUnit, unqExpander ); } void expandTuples( std::list< Declaration * > & translationUnit ) { - TupleAssignExpander assnExpander; + PassVisitor assnExpander; mutateAll( translationUnit, assnExpander ); @@ -113,5 +99,5 @@ mutateAll( translationUnit, idxExpander ); - TupleExprExpander exprExpander; + PassVisitor exprExpander; mutateAll( translationUnit, exprExpander ); } @@ -146,5 +132,5 @@ // aggregate expressions which might be impure must be wrapped in unique expressions // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr - // if ( Tuples::maybeImpure( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr ); + // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr ); aggr = new UniqueExpr( aggr ); for ( Expression *& expr : tupleExpr->get_exprs() ) { @@ -164,6 +150,5 @@ } - Expression * UniqueExprExpander::mutate( UniqueExpr * unqExpr ) { - unqExpr = safe_dynamic_cast< UniqueExpr * > ( Parent::mutate( unqExpr ) ); + Expression * UniqueExprExpander::postmutate( UniqueExpr * unqExpr ) { const int id = unqExpr->get_id(); @@ -175,5 +160,5 @@ if ( unqExpr->get_object() ) { // an object was generated to represent this unique expression -- it should be added to the list of declarations now - addDeclaration( unqExpr->get_object() ); + declsToAddBefore.push_back( unqExpr->get_object() ); unqExpr->set_object( nullptr ); // steal the expr from the unqExpr @@ -189,5 +174,5 @@ ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) ); - addDeclaration( finished ); + declsToAddBefore.push_back( finished ); // (finished ? _unq_expr_N : (_unq_expr_N = get_expr()>, finished = 1, _unq_expr_N)) // This pattern ensures that each unique expression is evaluated once, regardless of evaluation order of the generated C code. @@ -203,6 +188,5 @@ } - Expression * TupleAssignExpander::mutate( TupleAssignExpr * assnExpr ) { - assnExpr = safe_dynamic_cast< TupleAssignExpr * >( Parent::mutate( assnExpr ) ); + Expression * TupleAssignExpander::postmutate( TupleAssignExpr * assnExpr ) { StmtExpr * ret = assnExpr->get_stmtExpr(); assnExpr->set_stmtExpr( nullptr ); @@ -238,11 +222,5 @@ for ( auto p : group_iterate( tupleType->get_types(), decl->get_parameters() ) ) { Type * t = std::get<0>(p); - TypeDecl * td = std::get<1>(p); newType->get_parameters().push_back( new TypeExpr( t->clone() ) ); - if ( env ) { - // add bindings to the type environment. - // xxx - This may not be sufficient, it may be necessary to rename type variables on StructInstType? - env->add( td->get_name(), t->clone() ); - } } delete tupleType; @@ -293,7 +271,5 @@ } - Expression * TupleExprExpander::mutate( TupleExpr * tupleExpr ) { - // recursively expand sub-tuple-expressions - tupleExpr = safe_dynamic_cast(Parent::mutate(tupleExpr)); + Expression * TupleExprExpander::postmutate( TupleExpr * tupleExpr ) { Type * result = tupleExpr->get_result(); std::list< Expression * > exprs = tupleExpr->get_exprs(); @@ -342,4 +318,6 @@ class ImpurityDetector : public Visitor { public: + ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {} + typedef Visitor Parent; virtual void visit( ApplicationExpr * appExpr ) { @@ -355,11 +333,28 @@ maybeImpure = true; } - virtual void visit( __attribute__((unused)) UntypedExpr * untypedExpr ) { maybeImpure = true; } + virtual void visit( UntypedExpr * ) { maybeImpure = true; } + virtual void visit( UniqueExpr * unq ) { + if ( ignoreUnique ) { + // bottom out at unique expression. + // The existence of a unique expression doesn't change the purity of an expression. + // That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression. + return; + } + maybeAccept( unq->expr, *this ); + } + bool maybeImpure = false; + bool ignoreUnique; }; } // namespace bool maybeImpure( Expression * expr ) { - ImpurityDetector detector; + ImpurityDetector detector( false ); + expr->accept( detector ); + return detector.maybeImpure; + } + + bool maybeImpureIgnoreUnique( Expression * expr ) { + ImpurityDetector detector( true ); expr->accept( detector ); return detector.maybeImpure; Index: src/Tuples/Tuples.h =================================================================== --- src/Tuples/Tuples.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/Tuples/Tuples.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -46,4 +46,7 @@ /// returns true if the expression may contain side-effects. bool maybeImpure( Expression * expr ); + + /// returns true if the expression may contain side-effect, ignoring the presence of unique expressions. + bool maybeImpureIgnoreUnique( Expression * expr ); } // namespace Tuples Index: src/benchmark/csv-data.c =================================================================== --- src/benchmark/csv-data.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/benchmark/csv-data.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -8,9 +8,9 @@ coroutine GreatSuspender {}; -void ?{}( GreatSuspender * this ) { +void ?{}( GreatSuspender & this ) { prime(this); } -void main( GreatSuspender * this ) +void main( GreatSuspender & this ) { while( true ) { @@ -21,5 +21,5 @@ void resumer( GreatSuspender * this, const unsigned int NoOfTimes ) { for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) { - resume( this ); + resume( *this ); } } @@ -58,5 +58,5 @@ // single monitor entry monitor mon_t {}; -void dummy( mon_t * mutex m ) {} +void dummy( mon_t & mutex m ) {} long long int measure_1_monitor_entry() { @@ -67,5 +67,5 @@ StartTime = Time(); for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) { - dummy( &mon ); + dummy( mon ); } EndTime = Time(); @@ -76,5 +76,5 @@ //----------------------------------------------------------------------------- // multi monitor entry -void dummy( mon_t * mutex m1, mon_t * mutex m2 ) {} +void dummy( mon_t & mutex m1, mon_t & mutex m2 ) {} long long int measure_2_monitor_entry() { @@ -85,5 +85,5 @@ StartTime = Time(); for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) { - dummy( &mon1, &mon2 ); + dummy( mon1, mon2 ); } EndTime = Time(); @@ -102,9 +102,9 @@ thread thrd1b {}; -void ?{}( thrd1a * this, long long int * out ) { - this->out = out; -} - -void side1A( mon_t * mutex a, long long int * out ) { +void ?{}( thrd1a & this, long long int * out ) { + this.out = out; +} + +void side1A( mon_t & mutex a, long long int * out ) { long long int StartTime, EndTime; @@ -120,5 +120,5 @@ } -void side1B( mon_t * mutex a ) { +void side1B( mon_t & mutex a ) { for( int i = 0;; i++ ) { signal(&cond1b); @@ -128,6 +128,6 @@ } -void main( thrd1a * this ) { side1A( &mon1, this->out ); } -void main( thrd1b * this ) { side1B( &mon1 ); } +void main( thrd1a & this ) { side1A( mon1, this.out ); } +void main( thrd1b & this ) { side1B( mon1 ); } long long int measure_1_sched_int() { @@ -150,9 +150,9 @@ thread thrd2b {}; -void ?{}( thrd2a * this, long long int * out ) { - this->out = out; -} - -void side2A( mon_t * mutex a, mon_t * mutex b, long long int * out ) { +void ?{}( thrd2a & this, long long int * out ) { + this.out = out; +} + +void side2A( mon_t & mutex a, mon_t & mutex b, long long int * out ) { long long int StartTime, EndTime; @@ -168,5 +168,5 @@ } -void side2B( mon_t * mutex a, mon_t * mutex b ) { +void side2B( mon_t & mutex a, mon_t & mutex b ) { for( int i = 0;; i++ ) { signal(&cond2b); @@ -176,6 +176,6 @@ } -void main( thrd2a * this ) { side2A( &mon1, &mon2, this->out ); } -void main( thrd2b * this ) { side2B( &mon1, &mon2 ); } +void main( thrd2a & this ) { side2A( mon1, mon2, this.out ); } +void main( thrd2b & this ) { side2B( mon1, mon2 ); } long long int measure_2_sched_int() { Index: src/libcfa/Makefile.am =================================================================== --- src/libcfa/Makefile.am (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/Makefile.am (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -36,5 +36,5 @@ ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -O0 -c -o $@ $< -EXTRA_FLAGS = -g -Wall -Werror -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@ +EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@ AM_CCASFLAGS = @CFA_FLAGS@ Index: src/libcfa/Makefile.in =================================================================== --- src/libcfa/Makefile.in (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/Makefile.in (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -416,5 +416,5 @@ ARFLAGS = cr lib_LIBRARIES = $(am__append_1) $(am__append_2) -EXTRA_FLAGS = -g -Wall -Werror -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@ +EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@ AM_CCASFLAGS = @CFA_FLAGS@ headers = fstream iostream iterator limits rational stdlib \ Index: src/libcfa/concurrency/alarm.c =================================================================== --- src/libcfa/concurrency/alarm.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/alarm.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -40,24 +40,24 @@ __cfa_time_t zero_time = { 0 }; -void ?{}( __cfa_time_t * this ) { this->val = 0; } -void ?{}( __cfa_time_t * this, zero_t zero ) { this->val = 0; } - -void ?{}( itimerval * this, __cfa_time_t * alarm ) { - this->it_value.tv_sec = alarm->val / one_second; // seconds - this->it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds - this->it_interval.tv_sec = 0; - this->it_interval.tv_usec = 0; -} - - -void ?{}( __cfa_time_t * this, timespec * curr ) { +void ?{}( __cfa_time_t & this ) { this.val = 0; } +void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; } + +void ?{}( itimerval & this, __cfa_time_t * alarm ) { + this.it_value.tv_sec = alarm->val / one_second; // seconds + this.it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds + this.it_interval.tv_sec = 0; + this.it_interval.tv_usec = 0; +} + + +void ?{}( __cfa_time_t & this, timespec * curr ) { uint64_t secs = curr->tv_sec; uint64_t nsecs = curr->tv_nsec; - this->val = (secs * one_second) + nsecs; -} - -__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs ) { - this->val = 0; - return *this; + this.val = (secs * one_second) + nsecs; +} + +__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ) { + this.val = 0; + return this; } @@ -86,25 +86,25 @@ //============================================================================================= -void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) { - this->thrd = thrd; - this->alarm = alarm; - this->period = period; - this->next = 0; - this->set = false; - this->kernel_alarm = false; -} - -void ?{}( alarm_node_t * this, processor * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) { - this->proc = proc; - this->alarm = alarm; - this->period = period; - this->next = 0; - this->set = false; - this->kernel_alarm = true; -} - -void ^?{}( alarm_node_t * this ) { - if( this->set ) { - unregister_self( this ); +void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) { + this.thrd = thrd; + this.alarm = alarm; + this.period = period; + this.next = 0; + this.set = false; + this.kernel_alarm = false; +} + +void ?{}( alarm_node_t & this, processor * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) { + this.proc = proc; + this.alarm = alarm; + this.period = period; + this.next = 0; + this.set = false; + this.kernel_alarm = true; +} + +void ^?{}( alarm_node_t & this ) { + if( this.set ) { + unregister_self( &this ); } } Index: src/libcfa/concurrency/alarm.h =================================================================== --- src/libcfa/concurrency/alarm.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/alarm.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -36,10 +36,10 @@ // ctors -void ?{}( __cfa_time_t * this ); -void ?{}( __cfa_time_t * this, zero_t zero ); -void ?{}( __cfa_time_t * this, timespec * curr ); -void ?{}( itimerval * this, __cfa_time_t * alarm ); +void ?{}( __cfa_time_t & this ); +void ?{}( __cfa_time_t & this, zero_t zero ); +void ?{}( __cfa_time_t & this, timespec * curr ); +void ?{}( itimerval & this, __cfa_time_t * alarm ); -__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs ); +__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ); // logical ops @@ -105,7 +105,7 @@ typedef alarm_node_t ** __alarm_it_t; -void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ); -void ?{}( alarm_node_t * this, processor * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ); -void ^?{}( alarm_node_t * this ); +void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ); +void ?{}( alarm_node_t & this, processor * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ); +void ^?{}( alarm_node_t & this ); struct alarm_list_t { @@ -114,7 +114,7 @@ }; -static inline void ?{}( alarm_list_t * this ) { - this->head = 0; - this->tail = &this->head; +static inline void ?{}( alarm_list_t & this ) { + this.head = 0; + this.tail = &this.head; } Index: src/libcfa/concurrency/coroutine =================================================================== --- src/libcfa/concurrency/coroutine (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/coroutine (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -25,17 +25,17 @@ // Anything that is resumed is a coroutine. trait is_coroutine(dtype T) { - void main(T * this); - coroutine_desc * get_coroutine(T * this); + void main(T & this); + coroutine_desc * get_coroutine(T & this); }; -#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->__cor; } void main(X* this) +#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X& this) { return &this.__cor; } void main(X& this) //----------------------------------------------------------------------------- // Ctors and dtors -void ?{}(coStack_t * this); -void ?{}(coroutine_desc * this); -void ?{}(coroutine_desc * this, const char * name); -void ^?{}(coStack_t * this); -void ^?{}(coroutine_desc * this); +void ?{}(coStack_t & this); +void ?{}(coroutine_desc & this); +void ?{}(coroutine_desc & this, const char * name); +void ^?{}(coStack_t & this); +void ^?{}(coroutine_desc & this); //----------------------------------------------------------------------------- @@ -44,8 +44,8 @@ forall(dtype T | is_coroutine(T)) -static inline void resume(T * cor); +static inline void resume(T & cor); forall(dtype T | is_coroutine(T)) -void prime(T * cor); +void prime(T & cor); //----------------------------------------------------------------------------- @@ -86,5 +86,5 @@ // Resume implementation inlined for performance forall(dtype T | is_coroutine(T)) -static inline void resume(T * cor) { +static inline void resume(T & cor) { coroutine_desc * src = this_coroutine; // optimization coroutine_desc * dst = get_coroutine(cor); @@ -92,5 +92,5 @@ if( unlikely(!dst->stack.base) ) { create_stack(&dst->stack, dst->stack.size); - CtxStart(cor, CtxInvokeCoroutine); + CtxStart(&cor, CtxInvokeCoroutine); } Index: src/libcfa/concurrency/coroutine.c =================================================================== --- src/libcfa/concurrency/coroutine.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/coroutine.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -40,55 +40,55 @@ //----------------------------------------------------------------------------- // Coroutine ctors and dtors -void ?{}(coStack_t* this) { - this->size = 65000; // size of stack - this->storage = NULL; // pointer to stack - this->limit = NULL; // stack grows towards stack limit - this->base = NULL; // base of stack - this->context = NULL; // address of cfa_context_t - this->top = NULL; // address of top of storage - this->userStack = false; +void ?{}(coStack_t& this) { + this.size = 65000; // size of stack + this.storage = NULL; // pointer to stack + this.limit = NULL; // stack grows towards stack limit + this.base = NULL; // base of stack + this.context = NULL; // address of cfa_context_t + this.top = NULL; // address of top of storage + this.userStack = false; } -void ?{}(coStack_t* this, size_t size) { +void ?{}(coStack_t& this, size_t size) { this{}; - this->size = size; + this.size = size; - create_stack(this, this->size); + create_stack(&this, this.size); } -void ?{}(coroutine_desc* this) { +void ?{}(coroutine_desc& this) { this{ "Anonymous Coroutine" }; } -void ?{}(coroutine_desc* this, const char * name) { - this->name = name; - this->errno_ = 0; - this->state = Start; - this->starter = NULL; - this->last = NULL; +void ?{}(coroutine_desc& this, const char * name) { + this.name = name; + this.errno_ = 0; + this.state = Start; + this.starter = NULL; + this.last = NULL; } -void ?{}(coroutine_desc* this, size_t size) { +void ?{}(coroutine_desc& this, size_t size) { this{}; - (&this->stack){size}; + (this.stack){size}; } -void ^?{}(coStack_t* this) { - if ( ! this->userStack ) { +void ^?{}(coStack_t& this) { + if ( ! this.userStack ) { LIB_DEBUG_DO( - if ( mprotect( this->storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) { - abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", this, errno, strerror( errno ) ); + if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) { + abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) ); } ); - free( this->storage ); + free( this.storage ); } } -void ^?{}(coroutine_desc* this) {} +void ^?{}(coroutine_desc& this) {} // Part of the Public API // Not inline since only ever called once per coroutine forall(dtype T | is_coroutine(T)) -void prime(T* cor) { +void prime(T& cor) { coroutine_desc* this = get_coroutine(cor); assert(this->state == Start); Index: src/libcfa/concurrency/invoke.h =================================================================== --- src/libcfa/concurrency/invoke.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/invoke.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -47,14 +47,14 @@ #ifdef __CFORALL__ extern "Cforall" { - void ?{}( struct __thread_queue_t * ); + void ?{}( struct __thread_queue_t & ); void append( struct __thread_queue_t *, struct thread_desc * ); struct thread_desc * pop_head( struct __thread_queue_t * ); - void ?{}( struct __condition_stack_t * ); + void ?{}( struct __condition_stack_t & ); void push( struct __condition_stack_t *, struct __condition_criterion_t * ); struct __condition_criterion_t * pop( struct __condition_stack_t * ); - void ?{}(spinlock * this); - void ^?{}(spinlock * this); + void ?{}(spinlock & this); + void ^?{}(spinlock & this); } #endif Index: src/libcfa/concurrency/kernel =================================================================== --- src/libcfa/concurrency/kernel (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/kernel (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -37,6 +37,6 @@ }; -void ?{}(semaphore * this, int count = 1); -void ^?{}(semaphore * this); +void ?{}(semaphore & this, int count = 1); +void ^?{}(semaphore & this); void P(semaphore * this); void V(semaphore * this); @@ -51,6 +51,6 @@ }; -void ?{}(cluster * this); -void ^?{}(cluster * this); +void ?{}(cluster & this); +void ^?{}(cluster & this); //----------------------------------------------------------------------------- @@ -68,10 +68,10 @@ unsigned short thrd_count; }; -static inline void ?{}(FinishAction * this) { - this->action_code = No_Action; - this->thrd = NULL; - this->lock = NULL; +static inline void ?{}(FinishAction & this) { + this.action_code = No_Action; + this.thrd = NULL; + this.lock = NULL; } -static inline void ^?{}(FinishAction * this) {} +static inline void ^?{}(FinishAction & this) {} // Processor @@ -99,7 +99,7 @@ }; -void ?{}(processor * this); -void ?{}(processor * this, cluster * cltr); -void ^?{}(processor * this); +void ?{}(processor & this); +void ?{}(processor & this, cluster * cltr); +void ^?{}(processor & this); // Local Variables: // Index: src/libcfa/concurrency/kernel.c =================================================================== --- src/libcfa/concurrency/kernel.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/kernel.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -73,97 +73,97 @@ }; -void ?{}( current_stack_info_t * this ) { - CtxGet( this->ctx ); - this->base = this->ctx.FP; - this->storage = this->ctx.SP; +void ?{}( current_stack_info_t & this ) { + CtxGet( this.ctx ); + this.base = this.ctx.FP; + this.storage = this.ctx.SP; rlimit r; getrlimit( RLIMIT_STACK, &r); - this->size = r.rlim_cur; - - this->limit = (void *)(((intptr_t)this->base) - this->size); - this->context = &storage_mainThreadCtx; - this->top = this->base; -} - -void ?{}( coStack_t * this, current_stack_info_t * info) { - this->size = info->size; - this->storage = info->storage; - this->limit = info->limit; - this->base = info->base; - this->context = info->context; - this->top = info->top; - this->userStack = true; -} - -void ?{}( coroutine_desc * this, current_stack_info_t * info) { - (&this->stack){ info }; - this->name = "Main Thread"; - this->errno_ = 0; - this->state = Start; -} - -void ?{}( thread_desc * this, current_stack_info_t * info) { - (&this->cor){ info }; + this.size = r.rlim_cur; + + this.limit = (void *)(((intptr_t)this.base) - this.size); + this.context = &storage_mainThreadCtx; + this.top = this.base; +} + +void ?{}( coStack_t & this, current_stack_info_t * info) { + this.size = info->size; + this.storage = info->storage; + this.limit = info->limit; + this.base = info->base; + this.context = info->context; + this.top = info->top; + this.userStack = true; +} + +void ?{}( coroutine_desc & this, current_stack_info_t * info) { + (this.stack){ info }; + this.name = "Main Thread"; + this.errno_ = 0; + this.state = Start; +} + +void ?{}( thread_desc & this, current_stack_info_t * info) { + (this.cor){ info }; } //----------------------------------------------------------------------------- // Processor coroutine -void ?{}(processorCtx_t * this, processor * proc) { - (&this->__cor){ "Processor" }; - this->proc = proc; - proc->runner = this; -} - -void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) { - (&this->__cor){ info }; - this->proc = proc; - proc->runner = this; -} - -void ?{}(processor * this) { +void ?{}(processorCtx_t & this, processor * proc) { + (this.__cor){ "Processor" }; + this.proc = proc; + proc->runner = &this; +} + +void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) { + (this.__cor){ info }; + this.proc = proc; + proc->runner = &this; +} + +void ?{}(processor & this) { this{ mainCluster }; } -void ?{}(processor * this, cluster * cltr) { - this->cltr = cltr; - (&this->terminated){ 0 }; - this->do_terminate = false; - this->preemption_alarm = NULL; - this->pending_preemption = false; - - start( this ); -} - -void ?{}(processor * this, cluster * cltr, processorCtx_t * runner) { - this->cltr = cltr; - (&this->terminated){ 0 }; - this->do_terminate = false; - this->preemption_alarm = NULL; - this->pending_preemption = false; - this->kernel_thread = pthread_self(); - - this->runner = runner; - LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", runner); - runner{ this }; -} - -void ^?{}(processor * this) { - if( ! this->do_terminate ) { - LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this); - this->do_terminate = true; - P( &this->terminated ); - pthread_join( this->kernel_thread, NULL ); - } -} - -void ?{}(cluster * this) { - ( &this->ready_queue ){}; - ( &this->ready_queue_lock ){}; - - this->preemption = default_preemption(); -} - -void ^?{}(cluster * this) { +void ?{}(processor & this, cluster * cltr) { + this.cltr = cltr; + (this.terminated){ 0 }; + this.do_terminate = false; + this.preemption_alarm = NULL; + this.pending_preemption = false; + + start( &this ); +} + +void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) { + this.cltr = cltr; + (this.terminated){ 0 }; + this.do_terminate = false; + this.preemption_alarm = NULL; + this.pending_preemption = false; + this.kernel_thread = pthread_self(); + + this.runner = &runner; + LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner); + runner{ &this }; +} + +void ^?{}(processor & this) { + if( ! this.do_terminate ) { + LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this); + this.do_terminate = true; + P( &this.terminated ); + pthread_join( this.kernel_thread, NULL ); + } +} + +void ?{}(cluster & this) { + ( this.ready_queue ){}; + ( this.ready_queue_lock ){}; + + this.preemption = default_preemption(); +} + +void ^?{}(cluster & this) { } @@ -173,6 +173,6 @@ //============================================================================================= //Main of the processor contexts -void main(processorCtx_t * runner) { - processor * this = runner->proc; +void main(processorCtx_t & runner) { + processor * this = runner.proc; LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this); @@ -219,5 +219,5 @@ // from the processor coroutine to the target thread void runThread(processor * this, thread_desc * dst) { - coroutine_desc * proc_cor = get_coroutine(this->runner); + coroutine_desc * proc_cor = get_coroutine(*this->runner); coroutine_desc * thrd_cor = get_coroutine(dst); @@ -301,5 +301,5 @@ // appropriate stack. proc_cor_storage.__cor.state = Active; - main( &proc_cor_storage ); + main( proc_cor_storage ); proc_cor_storage.__cor.state = Halted; @@ -441,5 +441,5 @@ mainThread = (thread_desc *)&storage_mainThread; current_stack_info_t info; - mainThread{ &info }; + (*mainThread){ &info }; LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n"); @@ -447,5 +447,5 @@ // Initialize the main cluster mainCluster = (cluster *)&storage_mainCluster; - mainCluster{}; + (*mainCluster){}; LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n"); @@ -454,5 +454,5 @@ // (the coroutine that contains the processing control flow) mainProcessor = (processor *)&storage_mainProcessor; - mainProcessor{ mainCluster, (processorCtx_t *)&storage_mainProcessorCtx }; + (*mainProcessor){ mainCluster, *(processorCtx_t *)&storage_mainProcessorCtx }; //initialize the global state variables @@ -471,5 +471,5 @@ // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that // mainThread is on the ready queue when this call is made. - resume( mainProcessor->runner ); + resume( *mainProcessor->runner ); @@ -499,5 +499,5 @@ // Destroy the main processor and its context in reverse order of construction // These were manually constructed so we need manually destroy them - ^(mainProcessor->runner){}; + ^(*mainProcessor->runner){}; ^(mainProcessor){}; @@ -567,8 +567,8 @@ //----------------------------------------------------------------------------- // Locks -void ?{}( spinlock * this ) { - this->lock = 0; -} -void ^?{}( spinlock * this ) { +void ?{}( spinlock & this ) { + this.lock = 0; +} +void ^?{}( spinlock & this ) { } @@ -604,10 +604,10 @@ } -void ?{}( semaphore * this, int count = 1 ) { - (&this->lock){}; - this->count = count; - (&this->waiting){}; -} -void ^?{}(semaphore * this) {} +void ?{}( semaphore & this, int count = 1 ) { + (this.lock){}; + this.count = count; + (this.waiting){}; +} +void ^?{}(semaphore & this) {} void P(semaphore * this) { @@ -643,7 +643,7 @@ //----------------------------------------------------------------------------- // Queues -void ?{}( __thread_queue_t * this ) { - this->head = NULL; - this->tail = &this->head; +void ?{}( __thread_queue_t & this ) { + this.head = NULL; + this.tail = &this.head; } @@ -666,6 +666,6 @@ } -void ?{}( __condition_stack_t * this ) { - this->top = NULL; +void ?{}( __condition_stack_t & this ) { + this.top = NULL; } Index: src/libcfa/concurrency/monitor =================================================================== --- src/libcfa/concurrency/monitor (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/monitor (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -22,7 +22,7 @@ #include "stdlib" -static inline void ?{}(monitor_desc * this) { - this->owner = NULL; - this->recursion = 0; +static inline void ?{}(monitor_desc & this) { + this.owner = NULL; + this.recursion = 0; } @@ -38,6 +38,6 @@ } -void ?{}( monitor_guard_t * this, monitor_desc ** m, int count ); -void ^?{}( monitor_guard_t * this ); +void ?{}( monitor_guard_t & this, monitor_desc ** m, int count ); +void ^?{}( monitor_guard_t & this ); //----------------------------------------------------------------------------- @@ -64,5 +64,5 @@ }; -void ?{}( __condition_blocked_queue_t * ); +void ?{}( __condition_blocked_queue_t & ); void append( __condition_blocked_queue_t *, __condition_node_t * ); __condition_node_t * pop_head( __condition_blocked_queue_t * ); @@ -74,11 +74,11 @@ }; -static inline void ?{}( condition * this ) { - this->monitors = NULL; - this->monitor_count = 0; +static inline void ?{}( condition & this ) { + this.monitors = NULL; + this.monitor_count = 0; } -static inline void ^?{}( condition * this ) { - free( this->monitors ); +static inline void ^?{}( condition & this ) { + free( this.monitors ); } Index: src/libcfa/concurrency/monitor.c =================================================================== --- src/libcfa/concurrency/monitor.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/monitor.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -139,12 +139,12 @@ } -void ?{}( monitor_guard_t * this, monitor_desc ** m, int count ) { - this->m = m; - this->count = count; - qsort(this->m, count); - enter( this->m, this->count ); - - this->prev_mntrs = this_thread->current_monitors; - this->prev_count = this_thread->current_monitor_count; +void ?{}( monitor_guard_t & this, monitor_desc ** m, int count ) { + this.m = m; + this.count = count; + qsort(this.m, count); + enter( this.m, this.count ); + + this.prev_mntrs = this_thread->current_monitors; + this.prev_count = this_thread->current_monitor_count; this_thread->current_monitors = m; @@ -152,30 +152,30 @@ } -void ^?{}( monitor_guard_t * this ) { - leave( this->m, this->count ); - - this_thread->current_monitors = this->prev_mntrs; - this_thread->current_monitor_count = this->prev_count; -} - -void ?{}(__condition_node_t * this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) { - this->waiting_thread = waiting_thread; - this->count = count; - this->next = NULL; - this->user_info = user_info; -} - -void ?{}(__condition_criterion_t * this ) { - this->ready = false; - this->target = NULL; - this->owner = NULL; - this->next = NULL; -} - -void ?{}(__condition_criterion_t * this, monitor_desc * target, __condition_node_t * owner ) { - this->ready = false; - this->target = target; - this->owner = owner; - this->next = NULL; +void ^?{}( monitor_guard_t & this ) { + leave( this.m, this.count ); + + this_thread->current_monitors = this.prev_mntrs; + this_thread->current_monitor_count = this.prev_count; +} + +void ?{}(__condition_node_t & this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) { + this.waiting_thread = waiting_thread; + this.count = count; + this.next = NULL; + this.user_info = user_info; +} + +void ?{}(__condition_criterion_t & this ) { + this.ready = false; + this.target = NULL; + this.owner = NULL; + this.next = NULL; +} + +void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner ) { + this.ready = false; + this.target = target; + this.owner = owner; + this.next = NULL; } @@ -202,5 +202,5 @@ __condition_criterion_t criteria[count]; for(int i = 0; i < count; i++) { - (&criteria[i]){ this->monitors[i], &waiter }; + (criteria[i]){ this->monitors[i], &waiter }; // LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] ); } @@ -314,5 +314,5 @@ __condition_criterion_t criteria[count]; for(int i = 0; i < count; i++) { - (&criteria[i]){ this->monitors[i], &waiter }; + (criteria[i]){ this->monitors[i], &waiter }; // LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] ); push( &criteria[i].target->signal_stack, &criteria[i] ); @@ -505,7 +505,7 @@ } -void ?{}( __condition_blocked_queue_t * this ) { - this->head = NULL; - this->tail = &this->head; +void ?{}( __condition_blocked_queue_t & this ) { + this.head = NULL; + this.tail = &this.head; } Index: src/libcfa/concurrency/preemption.c =================================================================== --- src/libcfa/concurrency/preemption.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/preemption.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -71,7 +71,7 @@ static pthread_t alarm_thread; // pthread handle to alarm thread -void ?{}(event_kernel_t * this) { - (&this->alarms){}; - (&this->lock){}; +void ?{}(event_kernel_t & this) { + (this.alarms){}; + (this.lock){}; } @@ -240,5 +240,5 @@ // Initialize the event kernel event_kernel = (event_kernel_t *)&storage_event_kernel; - event_kernel{}; + (*event_kernel){}; // Setup proper signal handlers @@ -276,16 +276,16 @@ // Raii ctor/dtor for the preemption_scope // Used by thread to control when they want to receive preemption signals -void ?{}( preemption_scope * this, processor * proc ) { - (&this->alarm){ proc, zero_time, zero_time }; - this->proc = proc; - this->proc->preemption_alarm = &this->alarm; - - update_preemption( this->proc, from_us(this->proc->cltr->preemption) ); -} - -void ^?{}( preemption_scope * this ) { +void ?{}( preemption_scope & this, processor * proc ) { + (this.alarm){ proc, zero_time, zero_time }; + this.proc = proc; + this.proc->preemption_alarm = &this.alarm; + + update_preemption( this.proc, from_us(this.proc->cltr->preemption) ); +} + +void ^?{}( preemption_scope & this ) { disable_interrupts(); - update_preemption( this->proc, zero_time ); + update_preemption( this.proc, zero_time ); } Index: src/libcfa/concurrency/preemption.h =================================================================== --- src/libcfa/concurrency/preemption.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/preemption.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -30,6 +30,6 @@ }; -void ?{}( preemption_scope * this, processor * proc ); -void ^?{}( preemption_scope * this ); +void ?{}( preemption_scope & this, processor * proc ); +void ^?{}( preemption_scope & this ); // Local Variables: // Index: src/libcfa/concurrency/thread =================================================================== --- src/libcfa/concurrency/thread (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/thread (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -27,18 +27,18 @@ // Anything that is resumed is a coroutine. trait is_thread(dtype T) { - void ^?{}(T* mutex this); - void main(T* this); - thread_desc* get_thread(T* this); + void ^?{}(T& mutex this); + void main(T& this); + thread_desc* get_thread(T& this); }; -#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->__thrd; } void main(X* this) +#define DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this) forall( dtype T | is_thread(T) ) -static inline coroutine_desc* get_coroutine(T* this) { +static inline coroutine_desc* get_coroutine(T & this) { return &get_thread(this)->cor; } forall( dtype T | is_thread(T) ) -static inline monitor_desc* get_monitor(T * this) { +static inline monitor_desc* get_monitor(T & this) { return &get_thread(this)->mon; } @@ -55,10 +55,10 @@ forall( dtype T | is_thread(T) ) -void __thrd_start( T* this ); +void __thrd_start( T & this ); //----------------------------------------------------------------------------- // Ctors and dtors -void ?{}(thread_desc* this); -void ^?{}(thread_desc* this); +void ?{}(thread_desc& this); +void ^?{}(thread_desc& this); //----------------------------------------------------------------------------- @@ -70,12 +70,12 @@ }; -forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } ) -void ?{}( scoped(T)* this ); +forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } ) +void ?{}( scoped(T)& this ); -forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } ) -void ?{}( scoped(T)* this, P params ); +forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } ) +void ?{}( scoped(T)& this, P params ); forall( dtype T | sized(T) | is_thread(T) ) -void ^?{}( scoped(T)* this ); +void ^?{}( scoped(T)& this ); void yield(); Index: src/libcfa/concurrency/thread.c =================================================================== --- src/libcfa/concurrency/thread.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/concurrency/thread.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -32,34 +32,34 @@ // Thread ctors and dtors -void ?{}(thread_desc* this) { - (&this->cor){}; - this->cor.name = "Anonymous Coroutine"; - this->mon.owner = this; - this->mon.recursion = 1; - this->next = NULL; +void ?{}(thread_desc& this) { + (this.cor){}; + this.cor.name = "Anonymous Coroutine"; + this.mon.owner = &this; + this.mon.recursion = 1; + this.next = NULL; - this->current_monitors = &this->mon; - this->current_monitor_count = 1; + this.current_monitors = &this.mon; + this.current_monitor_count = 1; } -void ^?{}(thread_desc* this) { - ^(&this->cor){}; +void ^?{}(thread_desc& this) { + ^(this.cor){}; } -forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } ) -void ?{}( scoped(T)* this ) { - (&this->handle){}; - __thrd_start(&this->handle); +forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } ) +void ?{}( scoped(T)& this ) { + (this.handle){}; + __thrd_start(this.handle); } -forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } ) -void ?{}( scoped(T)* this, P params ) { - (&this->handle){ params }; - __thrd_start(&this->handle); +forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } ) +void ?{}( scoped(T)& this, P params ) { + (this.handle){ params }; + __thrd_start(this.handle); } forall( dtype T | sized(T) | is_thread(T) ) -void ^?{}( scoped(T)* this ) { - ^(&this->handle){}; +void ^?{}( scoped(T)& this ) { + ^(this.handle){}; } @@ -67,5 +67,5 @@ // Starting and stopping threads forall( dtype T | is_thread(T) ) -void __thrd_start( T* this ) { +void __thrd_start( T& this ) { coroutine_desc* thrd_c = get_coroutine(this); thread_desc* thrd_h = get_thread (this); @@ -77,5 +77,5 @@ create_stack(&thrd_c->stack, thrd_c->stack.size); this_coroutine = thrd_c; - CtxStart(this, CtxInvokeThread); + CtxStart(&this, CtxInvokeThread); assert( thrd_c->last->stack.context ); CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context ); Index: src/libcfa/containers/maybe =================================================================== --- src/libcfa/containers/maybe (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/containers/maybe (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -27,17 +27,17 @@ forall(otype T) -void ?{}(maybe(T) * this); +void ?{}(maybe(T) & this); forall(otype T) -void ?{}(maybe(T) * this, T value); +void ?{}(maybe(T) & this, T value); forall(otype T) -void ?{}(maybe(T) * this, maybe(T) other); +void ?{}(maybe(T) & this, maybe(T) other); forall(otype T) -void ^?{}(maybe(T) * this); +void ^?{}(maybe(T) & this); forall(otype T) -maybe(T) ?=?(maybe(T) * this, maybe(T) other); +maybe(T) ?=?(maybe(T) & this, maybe(T) other); forall(otype T) Index: src/libcfa/containers/maybe.c =================================================================== --- src/libcfa/containers/maybe.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/containers/maybe.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -19,39 +19,40 @@ forall(otype T) -void ?{}(maybe(T) * this) { - this->has_value = false; +void ?{}(maybe(T) & this) { + this.has_value = false; } forall(otype T) -void ?{}(maybe(T) * this, T value) { - this->has_value = true; - (&this->value){value}; +void ?{}(maybe(T) & this, T value) { + this.has_value = true; + (this.value){value}; } forall(otype T) -void ?{}(maybe(T) * this, maybe(T) other) { - this->has_value = other.has_value; +void ?{}(maybe(T) & this, maybe(T) other) { + this.has_value = other.has_value; if (other.has_value) { - (&this->value){other.value}; + (this.value){other.value}; } } forall(otype T) -maybe(T) ?=?(maybe(T) * this, maybe(T) that) { - if (this->has_value & that.has_value) { - this->value = that.value; - } else if (this->has_value) { - ^(&this->value){}; - this->has_value = false; +maybe(T) ?=?(maybe(T) & this, maybe(T) that) { + if (this.has_value & that.has_value) { + this.value = that.value; + } else if (this.has_value) { + ^(this.value){}; + this.has_value = false; } else if (that.has_value) { - this->has_value = true; - (&this->value){that.value}; + this.has_value = true; + (this.value){that.value}; } + return this; } forall(otype T) -void ^?{}(maybe(T) * this) { - if (this->has_value) { - ^(&this->value){}; +void ^?{}(maybe(T) & this) { + if (this.has_value) { + ^(this.value){}; } } @@ -89,5 +90,5 @@ } else { this->has_value = true; - (&this->value){value}; + (this->value){value}; } } @@ -97,5 +98,5 @@ if (this->has_value) { this->has_value = false; - ^(&this->value){}; + ^(this->value){}; } } Index: src/libcfa/containers/result =================================================================== --- src/libcfa/containers/result (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/containers/result (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -33,20 +33,20 @@ forall(otype T, otype E) -void ?{}(result(T, E) * this); +void ?{}(result(T, E) & this); forall(otype T, otype E) -void ?{}(result(T, E) * this, one_t, T value); +void ?{}(result(T, E) & this, one_t, T value); forall(otype T, otype E) -void ?{}(result(T, E) * this, zero_t, E error); +void ?{}(result(T, E) & this, zero_t, E error); forall(otype T, otype E) -void ?{}(result(T, E) * this, result(T, E) other); +void ?{}(result(T, E) & this, result(T, E) other); forall(otype T, otype E) -void ^?{}(result(T, E) * this); +void ^?{}(result(T, E) & this); forall(otype T, otype E) -result(T, E) ?=?(result(T, E) * this, result(T, E) other); +result(T, E) ?=?(result(T, E) & this, result(T, E) other); forall(otype T, otype E) Index: src/libcfa/containers/result.c =================================================================== --- src/libcfa/containers/result.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/containers/result.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -19,54 +19,54 @@ forall(otype T, otype E) -void ?{}(result(T, E) * this) { - this->has_value = false; - (&this->error){}; +void ?{}(result(T, E) & this) { + this.has_value = false; + (this.error){}; } forall(otype T, otype E) -void ?{}(result(T, E) * this, one_t, T value) { - this->has_value = true; - (&this->value){value}; +void ?{}(result(T, E) & this, one_t, T value) { + this.has_value = true; + (this.value){value}; } forall(otype T, otype E) -void ?{}(result(T, E) * this, zero_t, E error) { - this->has_value = false; - (&this->error){error}; +void ?{}(result(T, E) & this, zero_t, E error) { + this.has_value = false; + (this.error){error}; } forall(otype T, otype E) -void ?{}(result(T, E) * this, result(T, E) other) { - this->has_value = other.has_value; +void ?{}(result(T, E) & this, result(T, E) other) { + this.has_value = other.has_value; if (other.has_value) { - (&this->value){other.value}; + (this.value){other.value}; } else { - (&this->error){other.error}; + (this.error){other.error}; } } forall(otype T, otype E) -result(T, E) ?=?(result(T, E) * this, result(T, E) that) { - if (this->has_value & that.has_value) { - this->value = that.value; - } else if (this->has_value) { - ^(&this->value){}; - this->has_value = false; - (&this->error){that.error}; +result(T, E) ?=?(result(T, E) & this, result(T, E) that) { + if (this.has_value & that.has_value) { + this.value = that.value; + } else if (this.has_value) { + ^(this.value){}; + this.has_value = false; + (this.error){that.error}; } else if (that.has_value) { - ^(&this->error){}; - this->has_value = true; - (&this->value){that.value}; + ^(this.error){}; + this.has_value = true; + (this.value){that.value}; } else { - this->error = that.error; + this.error = that.error; } } forall(otype T, otype E) -void ^?{}(result(T, E) * this) { - if (this->has_value) { - ^(&this->value){}; +void ^?{}(result(T, E) & this) { + if (this.has_value) { + ^(this.value){}; } else { - ^(&this->error){}; + ^(this.error){}; } } @@ -109,7 +109,7 @@ this->value = value; } else { - ^(&this->error){}; + ^(this->error){}; this->has_value = true; - (&this->value){value}; + (this->value){value}; } } @@ -118,7 +118,7 @@ void set_error(result(T, E) * this, E error) { if (this->has_value) { - ^(&this->value){}; + ^(this->value){}; this->has_value = false; - (&this->error){error}; + (this->error){error}; } else { this->error = error; Index: src/libcfa/containers/vector =================================================================== --- src/libcfa/containers/vector (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/containers/vector (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -30,14 +30,14 @@ forall(otype T) -void ?{}(heap_allocator(T)* this); +void ?{}(heap_allocator(T)& this); forall(otype T) -void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs); +void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs); forall(otype T) -heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs); +heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs); forall(otype T) -void ^?{}(heap_allocator(T)* this); +void ^?{}(heap_allocator(T)& this); forall(otype T) @@ -64,14 +64,14 @@ //Initialization forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ?{}(vector(T, allocator_t)* this); +void ?{}(vector(T, allocator_t)& this); forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs); +void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs); forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs); +vector(T, allocator_t) ?=?(vector(T, allocator_t)& this, vector(T, allocator_t) rhs); forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ^?{}(vector(T, allocator_t)* this); +void ^?{}(vector(T, allocator_t)& this); forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t)) Index: src/libcfa/containers/vector.c =================================================================== --- src/libcfa/containers/vector.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/containers/vector.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -24,15 +24,15 @@ //Initialization forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ?{}(vector(T, allocator_t)* this) +void ?{}(vector(T, allocator_t)& this) { - (&this->storage){}; - this->size = 0; + (this.storage){}; + this.size = 0; } forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs) +void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs) { - (&this->storage){ rhs.storage }; - copy_internal(this, &rhs); + (this.storage){ rhs.storage }; + copy_internal(&this, &rhs); } @@ -46,8 +46,8 @@ forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ^?{}(vector(T, allocator_t)* this) +void ^?{}(vector(T, allocator_t)& this) { - clear(this); - ^(&this->storage){}; + clear(&this); + ^(this.storage){}; } @@ -66,5 +66,5 @@ { this->size--; - ^(&data(&this->storage)[this->size]){}; + ^(data(&this->storage)[this->size]){}; } @@ -74,5 +74,5 @@ for(size_t i = 0; i < this->size; i++) { - ^(&data(&this->storage)[this->size]){}; + ^(data(&this->storage)[this->size]){}; } this->size = 0; @@ -87,5 +87,5 @@ this->size = other->size; for(size_t i = 0; i < this->size; i++) { - (&data(&this->storage)[this->size]){ data(&other->storage)[other->size] }; + (data(&this->storage)[this->size]){ data(&other->storage)[other->size] }; } } @@ -94,29 +94,29 @@ //Allocator forall(otype T) -void ?{}(heap_allocator(T)* this) +void ?{}(heap_allocator(T)& this) { - this->storage = 0; - this->capacity = 0; + this.storage = 0; + this.capacity = 0; } forall(otype T) -void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs) +void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs) { - this->capacity = rhs.capacity; - this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T)); + this.capacity = rhs.capacity; + this.storage = (T*)realloc((void*)this.storage, this.capacity * sizeof(T)); } forall(otype T) -heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs) +heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs) { - this->capacity = rhs.capacity; - this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T)); - return *this; + this.capacity = rhs.capacity; + this.storage = (T*)realloc((void*)this.storage, this.capacity * sizeof(T)); + return this; } forall(otype T) -void ^?{}(heap_allocator(T)* this) +void ^?{}(heap_allocator(T)& this) { - free(this->storage); + free(this.storage); } Index: src/libcfa/fstream =================================================================== --- src/libcfa/fstream (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/fstream (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -56,5 +56,5 @@ int fmt( ofstream *, const char fmt[], ... ); -void ?{}( ofstream * ); +void ?{}( ofstream & ); extern ofstream * sout, * serr; Index: src/libcfa/fstream.c =================================================================== --- src/libcfa/fstream.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/fstream.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -27,11 +27,11 @@ #define IO_MSG "I/O error: " -void ?{}( ofstream * this, void * file, _Bool sepDefault, _Bool sepOnOff, const char * separator, const char * tupleSeparator ) { - this->file = file; - this->sepDefault = sepDefault; - this->sepOnOff = sepOnOff; - sepSet( this, separator ); - sepSetCur( this, sepGet( this ) ); - sepSetTuple( this, tupleSeparator ); +void ?{}( ofstream & this, void * file, _Bool sepDefault, _Bool sepOnOff, const char * separator, const char * tupleSeparator ) { + this.file = file; + this.sepDefault = sepDefault; + this.sepOnOff = sepOnOff; + sepSet( &this, separator ); + sepSetCur( &this, sepGet( &this ) ); + sepSetTuple( &this, tupleSeparator ); } @@ -92,5 +92,5 @@ exit( EXIT_FAILURE ); } // if - ?{}( os, file, true, false, " ", ", " ); + ?{}( *os, file, true, false, " ", ", " ); } // open Index: src/libcfa/gmp =================================================================== --- src/libcfa/gmp (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/gmp (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -1,10 +1,10 @@ -// +// // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo // // The contents of this file are covered under the licence agreement in the // file "LICENCE" distributed with Cforall. -// -// gmp -- -// +// +// gmp -- +// // Author : Peter A. Buhr // Created On : Tue Apr 19 08:43:43 2016 @@ -12,5 +12,5 @@ // Last Modified On : Fri Jul 7 09:33:20 2017 // Update Count : 15 -// +// // https://gmplib.org/gmp-man-6.1.1.pdf @@ -24,27 +24,27 @@ // constructor -static inline void ?{}( Int * this ) { mpz_init( this->mpz ); } -static inline void ?{}( Int * this, Int init ) { mpz_init_set( this->mpz, init.mpz ); } -static inline void ?{}( Int * this, zero_t ) { mpz_init_set_si( this->mpz, 0 ); } -static inline void ?{}( Int * this, one_t ) { mpz_init_set_si( this->mpz, 1 ); } -static inline void ?{}( Int * this, signed long int init ) { mpz_init_set_si( this->mpz, init ); } -static inline void ?{}( Int * this, unsigned long int init ) { mpz_init_set_ui( this->mpz, init ); } -static inline void ?{}( Int * this, const char * val ) { if ( mpz_init_set_str( this->mpz, val, 0 ) ) abort(); } -static inline void ^?{}( Int * this ) { mpz_clear( this->mpz ); } +static inline void ?{}( Int & this ) { mpz_init( this.mpz ); } +static inline void ?{}( Int & this, Int init ) { mpz_init_set( this.mpz, init.mpz ); } +static inline void ?{}( Int & this, zero_t ) { mpz_init_set_si( this.mpz, 0 ); } +static inline void ?{}( Int & this, one_t ) { mpz_init_set_si( this.mpz, 1 ); } +static inline void ?{}( Int & this, signed long int init ) { mpz_init_set_si( this.mpz, init ); } +static inline void ?{}( Int & this, unsigned long int init ) { mpz_init_set_ui( this.mpz, init ); } +static inline void ?{}( Int & this, const char * val ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); } +static inline void ^?{}( Int & this ) { mpz_clear( this.mpz ); } // assignment -static inline Int ?=?( Int * lhs, Int rhs ) { mpz_set( lhs->mpz, rhs.mpz ); return *lhs; } -static inline Int ?=?( Int * lhs, long int rhs ) { mpz_set_si( lhs->mpz, rhs ); return *lhs; } -static inline Int ?=?( Int * lhs, unsigned long int rhs ) { mpz_set_ui( lhs->mpz, rhs ); return *lhs; } -static inline Int ?=?( Int * lhs, const char * rhs ) { if ( mpz_set_str( lhs->mpz, rhs, 0 ) ) { printf( "invalid string conversion\n" ); abort(); } return *lhs; } - -static inline char ?=?( char * lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); *lhs = val; return val; } -static inline short int ?=?( short int * lhs, Int rhs ) { short int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; } -static inline int ?=?( int * lhs, Int rhs ) { int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; } -static inline long int ?=?( long int * lhs, Int rhs ) { long int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; } -static inline unsigned char ?=?( unsigned char * lhs, Int rhs ) { unsigned char val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; } -static inline unsigned short int ?=?( unsigned short int * lhs, Int rhs ) { unsigned short int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; } -static inline unsigned int ?=?( unsigned int * lhs, Int rhs ) { unsigned int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; } -static inline unsigned long int ?=?( unsigned long int * lhs, Int rhs ) { unsigned long int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; } +static inline Int ?=?( Int & lhs, Int rhs ) { mpz_set( lhs.mpz, rhs.mpz ); return lhs; } +static inline Int ?=?( Int & lhs, long int rhs ) { mpz_set_si( lhs.mpz, rhs ); return lhs; } +static inline Int ?=?( Int & lhs, unsigned long int rhs ) { mpz_set_ui( lhs.mpz, rhs ); return lhs; } +static inline Int ?=?( Int & lhs, const char * rhs ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { printf( "invalid string conversion\n" ); abort(); } return lhs; } + +static inline char ?=?( char & lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; } +static inline short int ?=?( short int & lhs, Int rhs ) { short int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; } +static inline int ?=?( int & lhs, Int rhs ) { int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; } +static inline long int ?=?( long int & lhs, Int rhs ) { long int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; } +static inline unsigned char ?=?( unsigned char & lhs, Int rhs ) { unsigned char val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; } +static inline unsigned short int ?=?( unsigned short int & lhs, Int rhs ) { unsigned short int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; } +static inline unsigned int ?=?( unsigned int & lhs, Int rhs ) { unsigned int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; } +static inline unsigned long int ?=?( unsigned long int & lhs, Int rhs ) { unsigned long int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; } // conversions @@ -99,5 +99,5 @@ static inline Int ?&?( Int oper1, unsigned long int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_and( conjunction.mpz, oper1.mpz, temp.mpz ); return conjunction; } static inline Int ?&?( unsigned long int oper1, Int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_and( conjunction.mpz, temp.mpz, oper2.mpz ); return conjunction; } -static inline Int ?&=?( Int * lhs, Int rhs ) { return *lhs = *lhs & rhs; } +static inline Int ?&=?( Int & lhs, Int rhs ) { return lhs = lhs & rhs; } static inline Int ?|?( Int oper1, Int oper2 ) { Int disjunction; mpz_ior( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; } @@ -106,5 +106,5 @@ static inline Int ?|?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; } static inline Int ?|?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; } -static inline Int ?|=?( Int * lhs, Int rhs ) { return *lhs = *lhs | rhs; } +static inline Int ?|=?( Int & lhs, Int rhs ) { return lhs = lhs | rhs; } static inline Int ?^?( Int oper1, Int oper2 ) { Int disjunction; mpz_xor( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; } @@ -113,5 +113,5 @@ static inline Int ?^?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; } static inline Int ?^?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; } -static inline Int ?^=?( Int * lhs, Int rhs ) { return *lhs = *lhs ^ rhs; } +static inline Int ?^=?( Int & lhs, Int rhs ) { return lhs = lhs ^ rhs; } static inline Int ?+?( Int addend1, Int addend2 ) { Int sum; mpz_add( sum.mpz, addend1.mpz, addend2.mpz ); return sum; } @@ -120,9 +120,9 @@ static inline Int ?+?( Int addend1, unsigned long int addend2 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; } static inline Int ?+?( unsigned long int addend2, Int addend1 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; } -static inline Int ?+=?( Int * lhs, Int rhs ) { return *lhs = *lhs + rhs; } -static inline Int ?+=?( Int * lhs, long int rhs ) { return *lhs = *lhs + rhs; } -static inline Int ?+=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs + rhs; } -static inline Int ++?( Int * lhs ) { return *lhs += 1; } -static inline Int ?++( Int * lhs ) { Int ret = *lhs; *lhs += 1; return ret; } +static inline Int ?+=?( Int & lhs, Int rhs ) { return lhs = lhs + rhs; } +static inline Int ?+=?( Int & lhs, long int rhs ) { return lhs = lhs + rhs; } +static inline Int ?+=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs + rhs; } +static inline Int ++?( Int & lhs ) { return lhs += 1; } +static inline Int ?++( Int & lhs ) { Int ret = lhs; lhs += 1; return ret; } static inline Int ?-?( Int minuend, Int subtrahend ) { Int diff; mpz_sub( diff.mpz, minuend.mpz, subtrahend.mpz ); return diff; } @@ -131,9 +131,9 @@ static inline Int ?-?( Int minuend, unsigned long int subtrahend ) { Int diff; mpz_sub_ui( diff.mpz, minuend.mpz, subtrahend ); return diff; } static inline Int ?-?( unsigned long int minuend, Int subtrahend ) { Int diff; mpz_ui_sub( diff.mpz, minuend, subtrahend.mpz ); return diff; } -static inline Int ?-=?( Int * lhs, Int rhs ) { return *lhs = *lhs - rhs; } -static inline Int ?-=?( Int * lhs, long int rhs ) { return *lhs = *lhs - rhs; } -static inline Int ?-=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs - rhs; } -static inline Int --?( Int * lhs ) { return *lhs -= 1; } -static inline Int ?--( Int * lhs ) { Int ret = *lhs; *lhs -= 1; return ret; } +static inline Int ?-=?( Int & lhs, Int rhs ) { return lhs = lhs - rhs; } +static inline Int ?-=?( Int & lhs, long int rhs ) { return lhs = lhs - rhs; } +static inline Int ?-=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs - rhs; } +static inline Int --?( Int & lhs ) { return lhs -= 1; } +static inline Int ?--( Int & lhs ) { Int ret = lhs; lhs -= 1; return ret; } static inline Int ?*?( Int multiplicator, Int multiplicand ) { Int product; mpz_mul( product.mpz, multiplicator.mpz, multiplicand.mpz ); return product; } @@ -142,7 +142,7 @@ static inline Int ?*?( Int multiplicator, unsigned long int multiplicand ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; } static inline Int ?*?( unsigned long int multiplicand, Int multiplicator ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; } -static inline Int ?*=?( Int * lhs, Int rhs ) { return *lhs = *lhs * rhs; } -static inline Int ?*=?( Int * lhs, long int rhs ) { return *lhs = *lhs * rhs; } -static inline Int ?*=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs * rhs; } +static inline Int ?*=?( Int & lhs, Int rhs ) { return lhs = lhs * rhs; } +static inline Int ?*=?( Int & lhs, long int rhs ) { return lhs = lhs * rhs; } +static inline Int ?*=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs * rhs; } // some code for operators "/" and "%" taken from g++ gmpxx.h @@ -187,7 +187,7 @@ return quotient; } // ?/? -static inline Int ?/=?( Int * lhs, Int rhs ) { return *lhs = *lhs / rhs; } -static inline Int ?/=?( Int * lhs, long int rhs ) { return *lhs = *lhs / rhs; } -static inline Int ?/=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs / rhs; } +static inline Int ?/=?( Int & lhs, Int rhs ) { return lhs = lhs / rhs; } +static inline Int ?/=?( Int & lhs, long int rhs ) { return lhs = lhs / rhs; } +static inline Int ?/=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs / rhs; } static inline [ Int, Int ] div( Int dividend, Int divisor ) { Int quotient, remainder; mpz_fdiv_qr( quotient.mpz, remainder.mpz, dividend.mpz, divisor.mpz ); return [ quotient, remainder ]; } @@ -228,12 +228,12 @@ return remainder; } // ?%? -static inline Int ?%=?( Int * lhs, Int rhs ) { return *lhs = *lhs % rhs; } -static inline Int ?%=?( Int * lhs, long int rhs ) { return *lhs = *lhs % rhs; } -static inline Int ?%=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs % rhs; } +static inline Int ?%=?( Int & lhs, Int rhs ) { return lhs = lhs % rhs; } +static inline Int ?%=?( Int & lhs, long int rhs ) { return lhs = lhs % rhs; } +static inline Int ?%=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs % rhs; } static inline Int ?<>?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_fdiv_q_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; } -static inline Int ?>>=?( Int * lhs, mp_bitcnt_t shift ) { return *lhs = *lhs >> shift; } +static inline Int ?>>=?( Int & lhs, mp_bitcnt_t shift ) { return lhs = lhs >> shift; } // number functions Index: src/libcfa/interpose.c =================================================================== --- src/libcfa/interpose.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/interpose.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -49,5 +49,5 @@ union { generic_fptr_t fptr; void* ptr; } originalFunc; - + #if defined( _GNU_SOURCE ) if ( version ) { @@ -59,7 +59,7 @@ originalFunc.ptr = dlsym( library, symbol ); #endif // _GNU_SOURCE - + error = dlerror(); - if ( error ) abortf( "interpose_symbol : internal error, %s\n", error ); + if ( error ) abortf( "interpose_symbol : internal error, %s\n", error ); return originalFunc.fptr; @@ -74,7 +74,7 @@ forall(dtype T) static inline void assign_ptr( T** symbol_ptr, const char * symbol_name, const char * version) { - union { + union { generic_fptr_t gp; - T* tp; + T* tp; } u; Index: src/libcfa/iterator =================================================================== --- src/libcfa/iterator (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/iterator (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -19,7 +19,7 @@ trait iterator( otype iterator_type, otype elt_type ) { // point to the next element -// iterator_type ?++( iterator_type * ); - iterator_type ++?( iterator_type * ); - iterator_type --?( iterator_type * ); +// iterator_type ?++( iterator_type & ); + iterator_type ++?( iterator_type & ); + iterator_type --?( iterator_type & ); // can be tested for equality with other iterators @@ -28,5 +28,5 @@ // dereference to get the pointed-at element - lvalue elt_type *?( iterator_type ); + elt_type & *?( iterator_type ); }; Index: src/libcfa/rational =================================================================== --- src/libcfa/rational (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/rational (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -31,6 +31,6 @@ int ?>?( T, T ); int ?>=?( T, T ); - void ?{}( T *, zero_t ); - void ?{}( T *, one_t ); + void ?{}( T &, zero_t ); + void ?{}( T &, one_t ); T +?( T ); T -?( T ); @@ -40,5 +40,5 @@ T ?/?( T, T ); T ?%?( T, T ); - T ?/=?( T *, T ); + T ?/=?( T &, T ); T abs( T ); }; @@ -54,17 +54,17 @@ forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r ); +void ?{}( Rational(RationalImpl) & r ); forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, RationalImpl n ); +void ?{}( Rational(RationalImpl) & r, RationalImpl n ); forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, RationalImpl n, RationalImpl d ); +void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ); forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, zero_t ); +void ?{}( Rational(RationalImpl) & r, zero_t ); forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, one_t ); +void ?{}( Rational(RationalImpl) & r, one_t ); // numerator/denominator getter @@ -77,5 +77,5 @@ forall( otype RationalImpl | arithmetic( RationalImpl ) ) -[ RationalImpl, RationalImpl ] ?=?( * [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ); +[ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ); // numerator/denominator setter Index: src/libcfa/rational.c =================================================================== --- src/libcfa/rational.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/rational.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -1,10 +1,10 @@ -// +// // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo // // The contents of this file are covered under the licence agreement in the // file "LICENCE" distributed with Cforall. -// -// rational.c -- -// +// +// rational.c -- +// // Author : Peter A. Buhr // Created On : Wed Apr 6 17:54:28 2016 @@ -12,5 +12,5 @@ // Last Modified On : Tue May 16 18:35:36 2017 // Update Count : 150 -// +// #include "rational" @@ -47,18 +47,18 @@ forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r ) { +void ?{}( Rational(RationalImpl) & r ) { r{ (RationalImpl){0}, (RationalImpl){1} }; } // rational forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, RationalImpl n ) { +void ?{}( Rational(RationalImpl) & r, RationalImpl n ) { r{ n, (RationalImpl){1} }; } // rational forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, RationalImpl n, RationalImpl d ) { +void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) { RationalImpl t = simplify( &n, &d ); // simplify - r->numerator = n / t; - r->denominator = d / t; + r.numerator = n / t; + r.denominator = d / t; } // rational @@ -77,6 +77,6 @@ forall( otype RationalImpl | arithmetic( RationalImpl ) ) -[ RationalImpl, RationalImpl ] ?=?( * [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ) { - return *dest = src.[ numerator, denominator ]; +[ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ) { + return dest = src.[ numerator, denominator ]; } Index: src/libcfa/stdlib =================================================================== --- src/libcfa/stdlib (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/libcfa/stdlib (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -132,12 +132,12 @@ // allocation/deallocation and constructor/destructor, non-array types -forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p ); -forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr ); -forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest ); +forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p ); +forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr ); +forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest ); // allocation/deallocation and constructor/destructor, array types -forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p ); -forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] ); -forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ); +forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p ); +forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] ); +forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ); //--------------------------------------- @@ -201,5 +201,5 @@ double abs( double _Complex ); long double abs( long double _Complex ); -forall( otype T | { void ?{}( T *, zero_t ); int ? olen ) { // larger ? memset( nptr + olen, (int)fill, nlen - olen ); // initialize added storage - } // + } // return (T *)nptr; } // alloc // allocation/deallocation and constructor/destructor, non-array types -forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) +forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p ) { - return (malloc()){ p }; // run constructor + return &(*malloc()){ p }; // run constructor } // new -forall( dtype T | { void ^?{}( T * ); } ) +forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr ) { if ( ptr ) { // ignore null - ^ptr{}; // run destructor + ^(*ptr){}; // run destructor free( ptr ); } // if } // delete -forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) +forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest ) { if ( ptr ) { // ignore null - ^ptr{}; // run destructor + ^(*ptr){}; // run destructor free( ptr ); } // if @@ -61,18 +61,18 @@ // allocation/deallocation and constructor/destructor, array types -forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) +forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p ) { T *arr = alloc( dim ); for ( unsigned int i = 0; i < dim; i += 1 ) { - (&arr[i]){ p }; // run constructor + (arr[i]){ p }; // run constructor } // for return arr; } // anew -forall( dtype T | sized(T) | { void ^?{}( T * ); } ) +forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] ) { if ( arr ) { // ignore null for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned - ^(&arr[i]){}; // run destructor + ^(arr[i]){}; // run destructor } // for free( arr ); @@ -80,9 +80,9 @@ } // adelete -forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) +forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ) { if ( arr ) { // ignore null for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned - ^(&arr[i]){}; // run destructor + ^(arr[i]){}; // run destructor } // for free( arr ); Index: src/prelude/builtins.c =================================================================== --- src/prelude/builtins.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/prelude/builtins.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -80,5 +80,5 @@ } // ?\? -static inline forall( otype T | { void ?{}( T * this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } ) +static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } ) double ?\?( T x, signed long int y ) { if ( y >= 0 ) return (double)(x \ (unsigned long int)y); @@ -86,8 +86,8 @@ } // ?\? -static inline long int ?\=?( long int * x, unsigned long int y ) { *x = *x \ y; return *x; } -static inline unsigned long int ?\=?( unsigned long int * x, unsigned long int y ) { *x = *x \ y; return *x; } -static inline int ?\=?( int * x, unsigned long int y ) { *x = *x \ y; return *x; } -static inline unsigned int ?\=?( unsigned int * x, unsigned long int y ) { *x = *x \ y; return *x; } +static inline long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; } +static inline unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; } +static inline int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; } +static inline unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; } // Local Variables: // Index: src/prelude/prelude.cf =================================================================== --- src/prelude/prelude.cf (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/prelude/prelude.cf (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -30,49 +30,49 @@ // ------------------------------------------------------------ -_Bool ?++( _Bool * ), ?++( volatile _Bool * ); -_Bool ?--( _Bool * ), ?--( volatile _Bool * ); -unsigned char ?++( unsigned char * ), ?++( volatile unsigned char * ); -signed int ?++( signed int * ), ?++( volatile signed int * ); -signed int ?--( signed int * ), ?--( volatile signed int * ); -unsigned int ?++( unsigned int * ), ?++( volatile unsigned int * ); -unsigned int ?--( unsigned int * ), ?--( volatile unsigned int * ); -signed long int ?++( signed long int * ), ?++( volatile signed long int * ); -signed long int ?--( signed long int * ), ?--( volatile signed long int * ); -unsigned long int ?++( unsigned long int * ), ?++( volatile unsigned long int * ); -unsigned long int ?--( unsigned long int * ), ?--( volatile unsigned long int * ); -signed long long int ?++( signed long long int * ), ?++( volatile signed long long int * ); -signed long long int ?--( signed long long int * ), ?--( volatile signed long long int * ); -unsigned long long int ?++( unsigned long long int * ), ?++( volatile unsigned long long int * ); -unsigned long long int ?--( unsigned long long int * ), ?--( volatile unsigned long long int * ); -float ?++( float * ), ?++( volatile float * ); -float ?--( float * ), ?--( volatile float * ); -double ?++( double * ), ?++( volatile double * ); -double ?--( double * ), ?--( volatile double * ); -long double ?++( long double * ), ?++( volatile long double * ); -long double ?--( long double * ), ?--( volatile long double * ); -float _Complex ?++( float _Complex * ), ?++( volatile float _Complex * ); -float _Complex ?--( float _Complex * ), ?--( volatile float _Complex * ); -double _Complex ?++( double _Complex * ), ?++( volatile double _Complex * ); -double _Complex ?--( double _Complex * ), ?--( volatile double _Complex * ); -long double _Complex ?++( long double _Complex * ), ?++( volatile long double _Complex * ); -long double _Complex ?--( long double _Complex * ), ?--( volatile long double _Complex * ); - -forall( dtype T | sized(T) ) T * ?++( T ** ); -forall( dtype T | sized(T) ) const T * ?++( const T ** ); -forall( dtype T | sized(T) ) volatile T * ?++( volatile T ** ); -forall( dtype T | sized(T) ) const volatile T * ?++( const volatile T ** ); -forall( dtype T | sized(T) ) T * ?--( T ** ); -forall( dtype T | sized(T) ) const T * ?--( const T ** ); -forall( dtype T | sized(T) ) volatile T * ?--( volatile T ** ); -forall( dtype T | sized(T) ) const volatile T * ?--( const volatile T ** ); - -forall( dtype T | sized(T) ) lvalue T ?[?]( T *, ptrdiff_t ); -forall( dtype T | sized(T) ) const lvalue T ?[?]( const T *, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile lvalue T ?[?]( volatile T *, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile lvalue T ?[?]( const volatile T *, ptrdiff_t ); -forall( dtype T | sized(T) ) lvalue T ?[?]( ptrdiff_t, T * ); -forall( dtype T | sized(T) ) const lvalue T ?[?]( ptrdiff_t, const T * ); -forall( dtype T | sized(T) ) volatile lvalue T ?[?]( ptrdiff_t, volatile T * ); -forall( dtype T | sized(T) ) const volatile lvalue T ?[?]( ptrdiff_t, const volatile T * ); +_Bool ?++( _Bool & ), ?++( volatile _Bool & ); +_Bool ?--( _Bool & ), ?--( volatile _Bool & ); +unsigned char ?++( unsigned char & ), ?++( volatile unsigned char & ); +signed int ?++( signed int & ), ?++( volatile signed int & ); +signed int ?--( signed int & ), ?--( volatile signed int & ); +unsigned int ?++( unsigned int & ), ?++( volatile unsigned int & ); +unsigned int ?--( unsigned int & ), ?--( volatile unsigned int & ); +signed long int ?++( signed long int & ), ?++( volatile signed long int & ); +signed long int ?--( signed long int & ), ?--( volatile signed long int & ); +unsigned long int ?++( unsigned long int & ), ?++( volatile unsigned long int & ); +unsigned long int ?--( unsigned long int & ), ?--( volatile unsigned long int & ); +signed long long int ?++( signed long long int & ), ?++( volatile signed long long int & ); +signed long long int ?--( signed long long int & ), ?--( volatile signed long long int & ); +unsigned long long int ?++( unsigned long long int & ), ?++( volatile unsigned long long int & ); +unsigned long long int ?--( unsigned long long int & ), ?--( volatile unsigned long long int & ); +float ?++( float & ), ?++( volatile float & ); +float ?--( float & ), ?--( volatile float & ); +double ?++( double & ), ?++( volatile double & ); +double ?--( double & ), ?--( volatile double & ); +long double ?++( long double & ), ?++( volatile long double & ); +long double ?--( long double & ), ?--( volatile long double & ); +float _Complex ?++( float _Complex & ), ?++( volatile float _Complex & ); +float _Complex ?--( float _Complex & ), ?--( volatile float _Complex & ); +double _Complex ?++( double _Complex & ), ?++( volatile double _Complex & ); +double _Complex ?--( double _Complex & ), ?--( volatile double _Complex & ); +long double _Complex ?++( long double _Complex & ), ?++( volatile long double _Complex & ); +long double _Complex ?--( long double _Complex & ), ?--( volatile long double _Complex & ); + +forall( dtype T | sized(T) ) T * ?++( T *& ); +forall( dtype T | sized(T) ) const T * ?++( const T *& ); +forall( dtype T | sized(T) ) volatile T * ?++( volatile T *& ); +forall( dtype T | sized(T) ) const volatile T * ?++( const volatile T *& ); +forall( dtype T | sized(T) ) T * ?--( T *& ); +forall( dtype T | sized(T) ) const T * ?--( const T *& ); +forall( dtype T | sized(T) ) volatile T * ?--( volatile T *& ); +forall( dtype T | sized(T) ) const volatile T * ?--( const volatile T *& ); + +forall( dtype T | sized(T) ) T & ?[?]( T *, ptrdiff_t ); +forall( dtype T | sized(T) ) const T & ?[?]( const T *, ptrdiff_t ); +forall( dtype T | sized(T) ) volatile T & ?[?]( volatile T *, ptrdiff_t ); +forall( dtype T | sized(T) ) const volatile T & ?[?]( const volatile T *, ptrdiff_t ); +forall( dtype T | sized(T) ) T & ?[?]( ptrdiff_t, T * ); +forall( dtype T | sized(T) ) const T & ?[?]( ptrdiff_t, const T * ); +forall( dtype T | sized(T) ) volatile T & ?[?]( ptrdiff_t, volatile T * ); +forall( dtype T | sized(T) ) const volatile T & ?[?]( ptrdiff_t, const volatile T * ); // ------------------------------------------------------------ @@ -82,32 +82,32 @@ // ------------------------------------------------------------ -_Bool ++?( _Bool * ), --?( _Bool * ); -signed int ++?( signed int * ), --?( signed int * ); -unsigned int ++?( unsigned int * ), --?( unsigned int * ); -signed long int ++?( signed long int * ), --?( signed long int * ); -unsigned long int ++?( unsigned long int * ), --?( unsigned 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 * ); -float ++?( float * ), --?( float * ); -double ++?( double * ), --?( double * ); -long double ++?( long double * ), --?( long double * ); -float _Complex ++?( float _Complex * ), --?( float _Complex * ); -double _Complex ++?( double _Complex * ), --?( double _Complex * ); -long double _Complex ++?( long double _Complex * ), --?( long double _Complex * ); - -forall( dtype T | sized(T) ) T * ++?( T ** ); -forall( dtype T | sized(T) ) const T * ++?( const T ** ); -forall( dtype T | sized(T) ) volatile T * ++?( volatile T ** ); -forall( dtype T | sized(T) ) const volatile T * ++?( const volatile T ** ); -forall( dtype T | sized(T) ) T * --?( T ** ); -forall( dtype T | sized(T) ) const T * --?( const T ** ); -forall( dtype T | sized(T) ) volatile T * --?( volatile T ** ); -forall( dtype T | sized(T) ) const volatile T * --?( const volatile T ** ); - -forall( dtype T | sized(T) ) lvalue T *?( T * ); -forall( dtype T | sized(T) ) const lvalue T *?( const T * ); -forall( dtype T | sized(T) ) volatile lvalue T *?( volatile T * ); -forall( dtype T | sized(T) ) const volatile lvalue T *?( const volatile T * ); -forall( ftype FT ) lvalue FT *?( FT * ); +_Bool ++?( _Bool & ), --?( _Bool & ); +signed int ++?( signed int & ), --?( signed int & ); +unsigned int ++?( unsigned int & ), --?( unsigned int & ); +signed long int ++?( signed long int & ), --?( signed long int & ); +unsigned long int ++?( unsigned long int & ), --?( unsigned 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 & ); +float ++?( float & ), --?( float & ); +double ++?( double & ), --?( double & ); +long double ++?( long double & ), --?( long double & ); +float _Complex ++?( float _Complex & ), --?( float _Complex & ); +double _Complex ++?( double _Complex & ), --?( double _Complex & ); +long double _Complex ++?( long double _Complex & ), --?( long double _Complex & ); + +forall( dtype T | sized(T) ) T * ++?( T *& ); +forall( dtype T | sized(T) ) const T * ++?( const T *& ); +forall( dtype T | sized(T) ) volatile T * ++?( volatile T *& ); +forall( dtype T | sized(T) ) const volatile T * ++?( const volatile T *& ); +forall( dtype T | sized(T) ) T * --?( T *& ); +forall( dtype T | sized(T) ) const T * --?( const T *& ); +forall( dtype T | sized(T) ) volatile T * --?( volatile T *& ); +forall( dtype T | sized(T) ) const volatile T * --?( const volatile T *& ); + +forall( dtype T | sized(T) ) T & *?( T * ); +forall( dtype T | sized(T) ) const T & *?( const T * ); +forall( dtype T | sized(T) ) volatile T & *?( volatile T * ); +forall( dtype T | sized(T) ) const volatile T & *?( const volatile T * ); +forall( ftype FT ) FT & *?( FT * ); _Bool +?( _Bool ), -?( _Bool ), ~?( _Bool ); @@ -366,295 +366,295 @@ // ------------------------------------------------------------ -forall( ftype FT ) FT * ?=?( FT **, FT * ); -forall( ftype FT ) FT * ?=?( FT * volatile *, FT * ); - -forall( dtype DT ) DT * ?=?( DT * *, DT * ); -forall( dtype DT ) DT * ?=?( DT * volatile *, DT * ); -forall( dtype DT ) const DT * ?=?( const DT * *, DT * ); -forall( dtype DT ) const DT * ?=?( const DT * volatile *, DT * ); -forall( dtype DT ) const DT * ?=?( const DT * *, const DT * ); -forall( dtype DT ) const DT * ?=?( const DT * volatile *, const DT * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * *, DT * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile *, DT * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * *, volatile DT * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile *, volatile DT * ); - -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, const DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, const DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, volatile DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, volatile DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, const volatile DT * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, const volatile DT * ); - -forall( dtype DT ) DT * ?=?( DT * *, void * ); -forall( dtype DT ) DT * ?=?( DT * volatile *, void * ); -forall( dtype DT ) const DT * ?=?( const DT * *, void * ); -forall( dtype DT ) const DT * ?=?( const DT * volatile *, void * ); -forall( dtype DT ) const DT * ?=?( const DT * *, const void * ); -forall( dtype DT ) const DT * ?=?( const DT * volatile *, const void * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * *, void * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile *, void * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * *, volatile void * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile *, volatile void * ); - -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, const void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, const void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, volatile void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, volatile void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, const volatile void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, const volatile void * ); - -forall( dtype DT ) void * ?=?( void * *, DT * ); -forall( dtype DT ) void * ?=?( void * volatile *, DT * ); -forall( dtype DT ) const void * ?=?( const void * *, DT * ); -forall( dtype DT ) const void * ?=?( const void * volatile *, DT * ); -forall( dtype DT ) const void * ?=?( const void * *, const DT * ); -forall( dtype DT ) const void * ?=?( const void * volatile *, const DT * ); -forall( dtype DT ) volatile void * ?=?( volatile void * *, DT * ); -forall( dtype DT ) volatile void * ?=?( volatile void * volatile *, DT * ); -forall( dtype DT ) volatile void * ?=?( volatile void * *, volatile DT * ); -forall( dtype DT ) volatile void * ?=?( volatile void * volatile *, volatile DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * *, DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *, DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * *, const DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *, const DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * *, volatile DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *, volatile DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * *, const volatile DT * ); -forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *, const volatile DT * ); - -void * ?=?( void * *, void * ); -void * ?=?( void * volatile *, void * ); -const void * ?=?( const void * *, void * ); -const void * ?=?( const void * volatile *, void * ); -const void * ?=?( const void * *, const void * ); -const void * ?=?( const void * volatile *, const void * ); -volatile void * ?=?( volatile void * *, void * ); -volatile void * ?=?( volatile void * volatile *, void * ); -volatile void * ?=?( volatile void * *, volatile void * ); -volatile void * ?=?( volatile void * volatile *, volatile void * ); -const volatile void * ?=?( const volatile void * *, void * ); -const volatile void * ?=?( const volatile void * volatile *, void * ); -const volatile void * ?=?( const volatile void * *, const void * ); -const volatile void * ?=?( const volatile void * volatile *, const void * ); -const volatile void * ?=?( const volatile void * *, volatile void * ); -const volatile void * ?=?( const volatile void * volatile *, volatile void * ); -const volatile void * ?=?( const volatile void * *, const volatile void * ); -const volatile void * ?=?( const volatile void * volatile *, const volatile void * ); - -// //forall( dtype DT ) DT * ?=?( DT * *, zero_t ); -// //forall( dtype DT ) DT * ?=?( DT * volatile *, zero_t ); -// forall( dtype DT ) const DT * ?=?( const DT * *, zero_t ); -// forall( dtype DT ) const DT * ?=?( const DT * volatile *, zero_t ); -// //forall( dtype DT ) volatile DT * ?=?( volatile DT * *, zero_t ); -// //forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile *, ); -// forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, zero_t ); -// forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, zero_t ); - -// forall( ftype FT ) FT * ?=?( FT * *, zero_t ); -// forall( ftype FT ) FT * ?=?( FT * volatile *, zero_t ); - -forall( dtype T | sized(T) ) T * ?+=?( T * *, ptrdiff_t ); -forall( dtype T | sized(T) ) T * ?+=?( T * volatile *, ptrdiff_t ); -forall( dtype T | sized(T) ) const T * ?+=?( const T * *, ptrdiff_t ); -forall( dtype T | sized(T) ) const T * ?+=?( const T * volatile *, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile T * ?+=?( volatile T * *, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile T * ?+=?( volatile T * volatile *, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T * *, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T * volatile *, ptrdiff_t ); -forall( dtype T | sized(T) ) T * ?-=?( T * *, ptrdiff_t ); -forall( dtype T | sized(T) ) T * ?-=?( T * volatile *, ptrdiff_t ); -forall( dtype T | sized(T) ) const T * ?-=?( const T * *, ptrdiff_t ); -forall( dtype T | sized(T) ) const T * ?-=?( const T * volatile *, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile T * ?-=?( volatile T * *, ptrdiff_t ); -forall( dtype T | sized(T) ) volatile T * ?-=?( volatile T * volatile *, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T * *, ptrdiff_t ); -forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T * volatile *, ptrdiff_t ); - -_Bool ?=?( _Bool *, _Bool ), ?=?( volatile _Bool *, _Bool ); -char ?=?( char *, char ), ?=?( volatile char *, char ); -char signed ?=?( char signed *, char signed ), ?=?( volatile char signed *, char signed ); -char unsigned ?=?( char unsigned *, char unsigned ), ?=?( volatile char unsigned *, char unsigned ); -int short ?=?( int short *, int short ), ?=?( volatile int short *, int short ); -int short unsigned ?=?( int short unsigned *, int short unsigned ), ?=?( volatile int short unsigned *, int short unsigned ); -signed int ?=?( signed int *, signed int ), ?=?( volatile signed int *, signed int ); -unsigned int ?=?( unsigned *, unsigned ), ?=?( volatile unsigned *, unsigned ); -signed long int ?=?( signed long int *, signed long int ), ?=?( volatile signed long int *, signed long int ); -unsigned long int ?=?( unsigned long int *, unsigned long int ), ?=?( volatile unsigned long int *, unsigned long int ); -signed long long int ?=?( signed long long int *, signed long long int ), ?=?( volatile signed long long int *, signed long long int ); -unsigned long long int ?=?( unsigned long long int *, unsigned long long int ), ?=?( volatile unsigned long long int *, unsigned long long int ); -zero_t ?=?( zero_t *, zero_t ); -one_t ?=?( one_t *, one_t ); - - -_Bool ?*=?( _Bool *, _Bool ), ?*=?( volatile _Bool *, _Bool ); -char ?*=?( char *, char ), ?*=?( volatile char *, char ); -char signed ?*=?( char signed *, char signed ), ?*=?( volatile char signed *, char signed ); -char unsigned ?*=?( char unsigned *, char unsigned ), ?*=?( volatile char unsigned *, char unsigned ); -int short ?*=?( int short *, int short ), ?*=?( volatile int short *, int short ); -int short unsigned ?*=?( int short unsigned *, int short unsigned ), ?*=?( volatile int short unsigned *, int short unsigned ); -signed int ?*=?( signed int *, signed int ), ?*=?( volatile signed int *, signed int ); -unsigned int ?*=?( unsigned *, unsigned ), ?*=?( volatile unsigned *, unsigned ); -signed long int ?*=?( signed long int *, signed long int ), ?*=?( volatile signed long int *, signed long int ); -unsigned long int ?*=?( unsigned long int *, unsigned long int ), ?*=?( volatile unsigned long int *, unsigned long int ); -signed long long int ?*=?( signed long long int *, signed long long int ), ?*=?( volatile signed long long int *, signed long long int ); -unsigned long long int ?*=?( unsigned long long int *, unsigned long long int ), ?*=?( volatile unsigned long long int *, unsigned long long int ); - -_Bool ?/=?( _Bool *, _Bool ), ?/=?( volatile _Bool *, _Bool ); -char ?/=?( char *, char ), ?/=?( volatile char *, char ); -char signed ?/=?( char signed *, char signed ), ?/=?( volatile char signed *, char signed ); -char unsigned ?/=?( char unsigned *, char unsigned ), ?/=?( volatile char unsigned *, char unsigned ); -int short ?/=?( int short *, int short ), ?/=?( volatile int short *, int short ); -int short unsigned ?/=?( int short unsigned *, int short unsigned ), ?/=?( volatile int short unsigned *, int short unsigned ); -signed int ?/=?( signed int *, signed int ), ?/=?( volatile signed int *, signed int ); -unsigned int ?/=?( unsigned *, unsigned ), ?/=?( volatile unsigned *, unsigned ); -signed long int ?/=?( signed long int *, signed long int ), ?/=?( volatile signed long int *, signed long int ); -unsigned long int ?/=?( unsigned long int *, unsigned long int ), ?/=?( volatile unsigned long int *, unsigned long int ); -signed long long int ?/=?( signed long long int *, signed long long int ), ?/=?( volatile signed long long int *, signed long long int ); -unsigned long long int ?/=?( unsigned long long int *, unsigned long long int ), ?/=?( volatile unsigned long long int *, unsigned long long int ); - -_Bool ?%=?( _Bool *, _Bool ), ?%=?( volatile _Bool *, _Bool ); -char ?%=?( char *, char ), ?%=?( volatile char *, char ); -char signed ?%=?( char signed *, char signed ), ?%=?( volatile char signed *, char signed ); -char unsigned ?%=?( char unsigned *, char unsigned ), ?%=?( volatile char unsigned *, char unsigned ); -int short ?%=?( int short *, int short ), ?%=?( volatile int short *, int short ); -int short unsigned ?%=?( int short unsigned *, int short unsigned ), ?%=?( volatile int short unsigned *, int short unsigned ); -signed int ?%=?( signed int *, signed int ), ?%=?( volatile signed int *, signed int ); -unsigned int ?%=?( unsigned *, unsigned ), ?%=?( volatile unsigned *, unsigned ); -signed long int ?%=?( signed long int *, signed long int ), ?%=?( volatile signed long int *, signed long int ); -unsigned long int ?%=?( unsigned long int *, unsigned long int ), ?%=?( volatile unsigned long int *, unsigned long int ); -signed long long int ?%=?( signed long long int *, signed long long int ), ?%=?( volatile signed long long int *, signed long long int ); -unsigned long long int ?%=?( unsigned long long int *, unsigned long long int ), ?%=?( volatile unsigned long long int *, unsigned long long int ); - -_Bool ?+=?( _Bool *, _Bool ), ?+=?( volatile _Bool *, _Bool ); -char ?+=?( char *, char ), ?+=?( volatile char *, char ); -char signed ?+=?( char signed *, char signed ), ?+=?( volatile char signed *, char signed ); -char unsigned ?+=?( char unsigned *, char unsigned ), ?+=?( volatile char unsigned *, char unsigned ); -int short ?+=?( int short *, int short ), ?+=?( volatile int short *, int short ); -int short unsigned ?+=?( int short unsigned *, int short unsigned ), ?+=?( volatile int short unsigned *, int short unsigned ); -signed int ?+=?( signed int *, signed int ), ?+=?( volatile signed int *, signed int ); -unsigned int ?+=?( unsigned *, unsigned ), ?+=?( volatile unsigned *, unsigned ); -signed long int ?+=?( signed long int *, signed long int ), ?+=?( volatile signed long int *, signed long int ); -unsigned long int ?+=?( unsigned long int *, unsigned long int ), ?+=?( volatile unsigned long int *, unsigned long int ); -signed long long int ?+=?( signed long long int *, signed long long int ), ?+=?( volatile signed long long int *, signed long long int ); -unsigned long long int ?+=?( unsigned long long int *, unsigned long long int ), ?+=?( volatile unsigned long long int *, unsigned long long int ); - -_Bool ?-=?( _Bool *, _Bool ), ?-=?( volatile _Bool *, _Bool ); -char ?-=?( char *, char ), ?-=?( volatile char *, char ); -char signed ?-=?( char signed *, char signed ), ?-=?( volatile char signed *, char signed ); -char unsigned ?-=?( char unsigned *, char unsigned ), ?-=?( volatile char unsigned *, char unsigned ); -int short ?-=?( int short *, int short ), ?-=?( volatile int short *, int short ); -int short unsigned ?-=?( int short unsigned *, int short unsigned ), ?-=?( volatile int short unsigned *, int short unsigned ); -signed int ?-=?( signed int *, signed int ), ?-=?( volatile signed int *, signed int ); -unsigned int ?-=?( unsigned *, unsigned ), ?-=?( volatile unsigned *, unsigned ); -signed long int ?-=?( signed long int *, signed long int ), ?-=?( volatile signed long int *, signed long int ); -unsigned long int ?-=?( unsigned long int *, unsigned long int ), ?-=?( volatile unsigned long int *, unsigned long int ); -signed long long int ?-=?( signed long long int *, signed long long int ), ?-=?( volatile signed long long int *, signed long long int ); -unsigned long long int ?-=?( unsigned long long int *, unsigned long long int ), ?-=?( volatile unsigned long long int *, unsigned long long int ); - -_Bool ?<<=?( _Bool *, _Bool ), ?<<=?( volatile _Bool *, _Bool ); -char ?<<=?( char *, char ), ?<<=?( volatile char *, char ); -char signed ?<<=?( char signed *, char signed ), ?<<=?( volatile char signed *, char signed ); -char unsigned ?<<=?( char unsigned *, char unsigned ), ?<<=?( volatile char unsigned *, char unsigned ); -int short ?<<=?( int short *, int short ), ?<<=?( volatile int short *, int short ); -int short unsigned ?<<=?( int short unsigned *, int short unsigned ), ?<<=?( volatile int short unsigned *, int short unsigned ); -signed int ?<<=?( signed int *, signed int ), ?<<=?( volatile signed int *, signed int ); -unsigned int ?<<=?( unsigned *, unsigned ), ?<<=?( volatile unsigned *, unsigned ); -signed long int ?<<=?( signed long int *, signed long int ), ?<<=?( volatile signed long int *, signed long int ); -unsigned long int ?<<=?( unsigned long int *, unsigned long int ), ?<<=?( volatile unsigned long int *, unsigned long int ); -signed long long int ?<<=?( signed long long int *, signed long long int ), ?<<=?( volatile signed long long int *, signed long long int ); -unsigned long long int ?<<=?( unsigned long long int *, unsigned long long int ), ?<<=?( volatile unsigned long long int *, unsigned long long int ); - -_Bool ?>>=?( _Bool *, _Bool ), ?>>=?( volatile _Bool *, _Bool ); -char ?>>=?( char *, char ), ?>>=?( volatile char *, char ); -char signed ?>>=?( char signed *, char signed ), ?>>=?( volatile char signed *, char signed ); -char unsigned ?>>=?( char unsigned *, char unsigned ), ?>>=?( volatile char unsigned *, char unsigned ); -int short ?>>=?( int short *, int short ), ?>>=?( volatile int short *, int short ); -int short unsigned ?>>=?( int short unsigned *, int short unsigned ), ?>>=?( volatile int short unsigned *, int short unsigned ); -signed int ?>>=?( signed int *, signed int ), ?>>=?( volatile signed int *, signed int ); -unsigned int ?>>=?( unsigned *, unsigned ), ?>>=?( volatile unsigned *, unsigned ); -signed long int ?>>=?( signed long int *, signed long int ), ?>>=?( volatile signed long int *, signed long int ); -unsigned long int ?>>=?( unsigned long int *, unsigned long int ), ?>>=?( volatile unsigned long int *, unsigned long int ); -signed long long int ?>>=?( signed long long int *, signed long long int ), ?>>=?( volatile signed long long int *, signed long long int ); -unsigned long long int ?>>=?( unsigned long long int *, unsigned long long int ), ?>>=?( volatile unsigned long long int *, unsigned long long int ); - -_Bool ?&=?( _Bool *, _Bool ), ?&=?( volatile _Bool *, _Bool ); -char ?&=?( char *, char ), ?&=?( volatile char *, char ); -char signed ?&=?( char signed *, char signed ), ?&=?( volatile char signed *, char signed ); -char unsigned ?&=?( char unsigned *, char unsigned ), ?&=?( volatile char unsigned *, char unsigned ); -int short ?&=?( int short *, int short ), ?&=?( volatile int short *, int short ); -int short unsigned ?&=?( int short unsigned *, int short unsigned ), ?&=?( volatile int short unsigned *, int short unsigned ); -signed int ?&=?( signed int *, signed int ), ?&=?( volatile signed int *, signed int ); -unsigned int ?&=?( unsigned *, unsigned ), ?&=?( volatile unsigned *, unsigned ); -signed long int ?&=?( signed long int *, signed long int ), ?&=?( volatile signed long int *, signed long int ); -unsigned long int ?&=?( unsigned long int *, unsigned long int ), ?&=?( volatile unsigned long int *, unsigned long int ); -signed long long int ?&=?( signed long long int *, signed long long int ), ?&=?( volatile signed long long int *, signed long long int ); -unsigned long long int ?&=?( unsigned long long int *, unsigned long long int ), ?&=?( volatile unsigned long long int *, unsigned long long int ); - -_Bool ?|=?( _Bool *, _Bool ), ?|=?( volatile _Bool *, _Bool ); -char ?|=?( char *, char ), ?|=?( volatile char *, char ); -char signed ?|=?( char signed *, char signed ), ?|=?( volatile char signed *, char signed ); -char unsigned ?|=?( char unsigned *, char unsigned ), ?|=?( volatile char unsigned *, char unsigned ); -int short ?|=?( int short *, int short ), ?|=?( volatile int short *, int short ); -int short unsigned ?|=?( int short unsigned *, int short unsigned ), ?|=?( volatile int short unsigned *, int short unsigned ); -signed int ?|=?( signed int *, signed int ), ?|=?( volatile signed int *, signed int ); -unsigned int ?|=?( unsigned *, unsigned ), ?|=?( volatile unsigned *, unsigned ); -signed long int ?|=?( signed long int *, signed long int ), ?|=?( volatile signed long int *, signed long int ); -unsigned long int ?|=?( unsigned long int *, unsigned long int ), ?|=?( volatile unsigned long int *, unsigned long int ); -signed long long int ?|=?( signed long long int *, signed long long int ), ?|=?( volatile signed long long int *, signed long long int ); -unsigned long long int ?|=?( unsigned long long int *, unsigned long long int ), ?|=?( volatile unsigned long long int *, unsigned long long int ); - -_Bool ?^=?( _Bool *, _Bool ), ?^=?( volatile _Bool *, _Bool ); -char ?^=?( char *, char ), ?^=?( volatile char *, char ); -char signed ?^=?( char signed *, char signed ), ?^=?( volatile char signed *, char signed ); -char unsigned ?^=?( char unsigned *, char unsigned ), ?^=?( volatile char unsigned *, char unsigned ); -int short ?^=?( int short *, int short ), ?^=?( volatile int short *, int short ); -int short unsigned ?^=?( int short unsigned *, int short unsigned ), ?^=?( volatile int short unsigned *, int short unsigned ); -signed int ?^=?( signed int *, signed int ), ?^=?( volatile signed int *, signed int ); -unsigned int ?^=?( unsigned *, unsigned ), ?^=?( volatile unsigned *, unsigned ); -signed long int ?^=?( signed long int *, signed long int ), ?^=?( volatile signed long int *, signed long int ); -unsigned long int ?^=?( unsigned long int *, unsigned long int ), ?^=?( volatile unsigned long int *, unsigned long int ); -signed long long int ?^=?( signed long long int *, signed long long int ), ?^=?( volatile signed long long int *, signed long long int ); -unsigned long long int ?^=?( unsigned long long int *, unsigned long long int ), ?^=?( volatile unsigned long long int *, unsigned long long int ); - -float ?=?( float *, float ), ?=?( volatile float *, float ), - ?*=?( float *, float ), ?*=?( volatile float *, float ), - ?/=?( float *, float ), ?/=?( volatile float *, float ), - ?+=?( float *, float ), ?+=?( volatile float *, float ), - ?-=?( float *, float ), ?-=?( volatile float *, float ); - -double ?=?( double *, double ), ?=?( volatile double *, double ), - ?*=?( double *, double ), ?*=?( volatile double *, double ), - ?/=?( double *, double ), ?/=?( volatile double *, double ), - ?+=?( double *, double ), ?+=?( volatile double *, double ), - ?-=?( double *, double ), ?-=?( volatile double *, double ); - -long double ?=?( long double *, long double ), ?=?( volatile long double *, long double ), - ?*=?( long double *, long double ), ?*=?( volatile long double *, long double ), - ?/=?( long double *, long double ), ?/=?( volatile long double *, long double ), - ?+=?( long double *, long double ), ?+=?( volatile long double *, long double ), - ?-=?( long double *, long double ), ?-=?( volatile long double *, long double ); - -float _Complex ?=?( float _Complex *, float _Complex ), ?=?( volatile float _Complex *, float _Complex ), - ?*=?( float _Complex *, float _Complex ), ?*=?( volatile float _Complex *, float _Complex ), - ?/=?( float _Complex *, float _Complex ), ?/=?( volatile float _Complex *, float _Complex ), - ?+=?( float _Complex *, float _Complex ), ?+=?( volatile float _Complex *, float _Complex ), - ?-=?( float _Complex *, float _Complex ), ?-=?( volatile float _Complex *, float _Complex ); - -double _Complex ?=?( double _Complex *, double _Complex ), ?=?( volatile double _Complex *, double _Complex ), - ?*=?( double _Complex *, double _Complex ), ?*=?( volatile double _Complex *, double _Complex ), - ?/=?( double _Complex *, double _Complex ), ?/=?( volatile double _Complex *, double _Complex ), - ?+=?( double _Complex *, double _Complex ), ?+=?( volatile double _Complex *, double _Complex ), - ?-=?( double _Complex *, double _Complex ), ?-=?( volatile double _Complex *, double _Complex ); - -long double _Complex ?=?( 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 ), - ?/=?( 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 ), - ?-=?( long double _Complex *, long double _Complex ), ?-=?( volatile long double _Complex *, long double _Complex ); +forall( ftype FT ) FT * ?=?( FT *&, FT * ); +forall( ftype FT ) FT * ?=?( FT * volatile &, FT * ); + +forall( dtype DT ) DT * ?=?( DT * &, DT * ); +forall( dtype DT ) DT * ?=?( DT * volatile &, DT * ); +forall( dtype DT ) const DT * ?=?( const DT * &, DT * ); +forall( dtype DT ) const DT * ?=?( const DT * volatile &, DT * ); +forall( dtype DT ) const DT * ?=?( const DT * &, const DT * ); +forall( dtype DT ) const DT * ?=?( const DT * volatile &, const DT * ); +forall( dtype DT ) volatile DT * ?=?( volatile DT * &, DT * ); +forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile &, DT * ); +forall( dtype DT ) volatile DT * ?=?( volatile DT * &, volatile DT * ); +forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile &, volatile DT * ); + +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, DT * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, DT * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, const DT * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, const DT * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, volatile DT * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, volatile DT * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, const volatile DT * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, const volatile DT * ); + +forall( dtype DT ) DT * ?=?( DT * &, void * ); +forall( dtype DT ) DT * ?=?( DT * volatile &, void * ); +forall( dtype DT ) const DT * ?=?( const DT * &, void * ); +forall( dtype DT ) const DT * ?=?( const DT * volatile &, void * ); +forall( dtype DT ) const DT * ?=?( const DT * &, const void * ); +forall( dtype DT ) const DT * ?=?( const DT * volatile &, const void * ); +forall( dtype DT ) volatile DT * ?=?( volatile DT * &, void * ); +forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile &, void * ); +forall( dtype DT ) volatile DT * ?=?( volatile DT * &, volatile void * ); +forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile &, volatile void * ); + +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, void * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, void * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, const void * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, const void * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, volatile void * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, volatile void * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, const volatile void * ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, const volatile void * ); + +forall( dtype DT ) void * ?=?( void * &, DT * ); +forall( dtype DT ) void * ?=?( void * volatile &, DT * ); +forall( dtype DT ) const void * ?=?( const void * &, DT * ); +forall( dtype DT ) const void * ?=?( const void * volatile &, DT * ); +forall( dtype DT ) const void * ?=?( const void * &, const DT * ); +forall( dtype DT ) const void * ?=?( const void * volatile &, const DT * ); +forall( dtype DT ) volatile void * ?=?( volatile void * &, DT * ); +forall( dtype DT ) volatile void * ?=?( volatile void * volatile &, DT * ); +forall( dtype DT ) volatile void * ?=?( volatile void * &, volatile DT * ); +forall( dtype DT ) volatile void * ?=?( volatile void * volatile &, volatile DT * ); +forall( dtype DT ) const volatile void * ?=?( const volatile void * &, DT * ); +forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, DT * ); +forall( dtype DT ) const volatile void * ?=?( const volatile void * &, const DT * ); +forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const DT * ); +forall( dtype DT ) const volatile void * ?=?( const volatile void * &, volatile DT * ); +forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, volatile DT * ); +forall( dtype DT ) const volatile void * ?=?( const volatile void * &, const volatile DT * ); +forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const volatile DT * ); + +void * ?=?( void * &, void * ); +void * ?=?( void * volatile &, void * ); +const void * ?=?( const void * &, void * ); +const void * ?=?( const void * volatile &, void * ); +const void * ?=?( const void * &, const void * ); +const void * ?=?( const void * volatile &, const void * ); +volatile void * ?=?( volatile void * &, void * ); +volatile void * ?=?( volatile void * volatile &, void * ); +volatile void * ?=?( volatile void * &, volatile void * ); +volatile void * ?=?( volatile void * volatile &, volatile void * ); +const volatile void * ?=?( const volatile void * &, void * ); +const volatile void * ?=?( const volatile void * volatile &, void * ); +const volatile void * ?=?( const volatile void * &, const void * ); +const volatile void * ?=?( const volatile void * volatile &, const void * ); +const volatile void * ?=?( const volatile void * &, volatile void * ); +const volatile void * ?=?( const volatile void * volatile &, volatile void * ); +const volatile void * ?=?( const volatile void * &, const volatile void * ); +const volatile void * ?=?( const volatile void * volatile &, const volatile void * ); + +//forall( dtype DT ) DT * ?=?( DT * &, zero_t ); +//forall( dtype DT ) DT * ?=?( DT * volatile &, zero_t ); +forall( dtype DT ) const DT * ?=?( const DT * &, zero_t ); +forall( dtype DT ) const DT * ?=?( const DT * volatile &, zero_t ); +//forall( dtype DT ) volatile DT * ?=?( volatile DT * &, zero_t ); +//forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile &, zero_t ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, zero_t ); +forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, zero_t ); + +forall( ftype FT ) FT * ?=?( FT * &, zero_t ); +forall( ftype FT ) FT * ?=?( FT * volatile &, zero_t ); + +forall( dtype T | sized(T) ) T * ?+=?( T * &, ptrdiff_t ); +forall( dtype T | sized(T) ) T * ?+=?( T * volatile &, ptrdiff_t ); +forall( dtype T | sized(T) ) const T * ?+=?( const T * &, ptrdiff_t ); +forall( dtype T | sized(T) ) const T * ?+=?( const T * volatile &, ptrdiff_t ); +forall( dtype T | sized(T) ) volatile T * ?+=?( volatile T * &, ptrdiff_t ); +forall( dtype T | sized(T) ) volatile T * ?+=?( volatile T * volatile &, ptrdiff_t ); +forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T * &, ptrdiff_t ); +forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T * volatile &, ptrdiff_t ); +forall( dtype T | sized(T) ) T * ?-=?( T * &, ptrdiff_t ); +forall( dtype T | sized(T) ) T * ?-=?( T * volatile &, ptrdiff_t ); +forall( dtype T | sized(T) ) const T * ?-=?( const T * &, ptrdiff_t ); +forall( dtype T | sized(T) ) const T * ?-=?( const T * volatile &, ptrdiff_t ); +forall( dtype T | sized(T) ) volatile T * ?-=?( volatile T * &, ptrdiff_t ); +forall( dtype T | sized(T) ) volatile T * ?-=?( volatile T * volatile &, ptrdiff_t ); +forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T * &, ptrdiff_t ); +forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T * volatile &, ptrdiff_t ); + +_Bool ?=?( _Bool &, _Bool ), ?=?( volatile _Bool &, _Bool ); +char ?=?( char &, char ), ?=?( volatile char &, char ); +char signed ?=?( char signed &, char signed ), ?=?( volatile char signed &, char signed ); +char unsigned ?=?( char unsigned &, char unsigned ), ?=?( volatile char unsigned &, char unsigned ); +int short ?=?( int short &, int short ), ?=?( volatile int short &, int short ); +int short unsigned ?=?( int short unsigned &, int short unsigned ), ?=?( volatile int short unsigned &, int short unsigned ); +signed int ?=?( signed int &, signed int ), ?=?( volatile signed int &, signed int ); +unsigned int ?=?( unsigned &, unsigned ), ?=?( volatile unsigned &, unsigned ); +signed long int ?=?( signed long int &, signed long int ), ?=?( volatile signed long int &, signed long int ); +unsigned long int ?=?( unsigned long int &, unsigned long int ), ?=?( volatile unsigned long int &, unsigned long int ); +signed long long int ?=?( signed long long int &, signed long long int ), ?=?( volatile signed long long int &, signed long long int ); +unsigned long long int ?=?( unsigned long long int &, unsigned long long int ), ?=?( volatile unsigned long long int &, unsigned long long int ); +zero_t ?=?( zero_t &, zero_t ); +one_t ?=?( one_t &, one_t ); + + +_Bool ?*=?( _Bool &, _Bool ), ?*=?( volatile _Bool &, _Bool ); +char ?*=?( char &, char ), ?*=?( volatile char &, char ); +char signed ?*=?( char signed &, char signed ), ?*=?( volatile char signed &, char signed ); +char unsigned ?*=?( char unsigned &, char unsigned ), ?*=?( volatile char unsigned &, char unsigned ); +int short ?*=?( int short &, int short ), ?*=?( volatile int short &, int short ); +int short unsigned ?*=?( int short unsigned &, int short unsigned ), ?*=?( volatile int short unsigned &, int short unsigned ); +signed int ?*=?( signed int &, signed int ), ?*=?( volatile signed int &, signed int ); +unsigned int ?*=?( unsigned &, unsigned ), ?*=?( volatile unsigned &, unsigned ); +signed long int ?*=?( signed long int &, signed long int ), ?*=?( volatile signed long int &, signed long int ); +unsigned long int ?*=?( unsigned long int &, unsigned long int ), ?*=?( volatile unsigned long int &, unsigned long int ); +signed long long int ?*=?( signed long long int &, signed long long int ), ?*=?( volatile signed long long int &, signed long long int ); +unsigned long long int ?*=?( unsigned long long int &, unsigned long long int ), ?*=?( volatile unsigned long long int &, unsigned long long int ); + +_Bool ?/=?( _Bool &, _Bool ), ?/=?( volatile _Bool &, _Bool ); +char ?/=?( char &, char ), ?/=?( volatile char &, char ); +char signed ?/=?( char signed &, char signed ), ?/=?( volatile char signed &, char signed ); +char unsigned ?/=?( char unsigned &, char unsigned ), ?/=?( volatile char unsigned &, char unsigned ); +int short ?/=?( int short &, int short ), ?/=?( volatile int short &, int short ); +int short unsigned ?/=?( int short unsigned &, int short unsigned ), ?/=?( volatile int short unsigned &, int short unsigned ); +signed int ?/=?( signed int &, signed int ), ?/=?( volatile signed int &, signed int ); +unsigned int ?/=?( unsigned &, unsigned ), ?/=?( volatile unsigned &, unsigned ); +signed long int ?/=?( signed long int &, signed long int ), ?/=?( volatile signed long int &, signed long int ); +unsigned long int ?/=?( unsigned long int &, unsigned long int ), ?/=?( volatile unsigned long int &, unsigned long int ); +signed long long int ?/=?( signed long long int &, signed long long int ), ?/=?( volatile signed long long int &, signed long long int ); +unsigned long long int ?/=?( unsigned long long int &, unsigned long long int ), ?/=?( volatile unsigned long long int &, unsigned long long int ); + +_Bool ?%=?( _Bool &, _Bool ), ?%=?( volatile _Bool &, _Bool ); +char ?%=?( char &, char ), ?%=?( volatile char &, char ); +char signed ?%=?( char signed &, char signed ), ?%=?( volatile char signed &, char signed ); +char unsigned ?%=?( char unsigned &, char unsigned ), ?%=?( volatile char unsigned &, char unsigned ); +int short ?%=?( int short &, int short ), ?%=?( volatile int short &, int short ); +int short unsigned ?%=?( int short unsigned &, int short unsigned ), ?%=?( volatile int short unsigned &, int short unsigned ); +signed int ?%=?( signed int &, signed int ), ?%=?( volatile signed int &, signed int ); +unsigned int ?%=?( unsigned &, unsigned ), ?%=?( volatile unsigned &, unsigned ); +signed long int ?%=?( signed long int &, signed long int ), ?%=?( volatile signed long int &, signed long int ); +unsigned long int ?%=?( unsigned long int &, unsigned long int ), ?%=?( volatile unsigned long int &, unsigned long int ); +signed long long int ?%=?( signed long long int &, signed long long int ), ?%=?( volatile signed long long int &, signed long long int ); +unsigned long long int ?%=?( unsigned long long int &, unsigned long long int ), ?%=?( volatile unsigned long long int &, unsigned long long int ); + +_Bool ?+=?( _Bool &, _Bool ), ?+=?( volatile _Bool &, _Bool ); +char ?+=?( char &, char ), ?+=?( volatile char &, char ); +char signed ?+=?( char signed &, char signed ), ?+=?( volatile char signed &, char signed ); +char unsigned ?+=?( char unsigned &, char unsigned ), ?+=?( volatile char unsigned &, char unsigned ); +int short ?+=?( int short &, int short ), ?+=?( volatile int short &, int short ); +int short unsigned ?+=?( int short unsigned &, int short unsigned ), ?+=?( volatile int short unsigned &, int short unsigned ); +signed int ?+=?( signed int &, signed int ), ?+=?( volatile signed int &, signed int ); +unsigned int ?+=?( unsigned &, unsigned ), ?+=?( volatile unsigned &, unsigned ); +signed long int ?+=?( signed long int &, signed long int ), ?+=?( volatile signed long int &, signed long int ); +unsigned long int ?+=?( unsigned long int &, unsigned long int ), ?+=?( volatile unsigned long int &, unsigned long int ); +signed long long int ?+=?( signed long long int &, signed long long int ), ?+=?( volatile signed long long int &, signed long long int ); +unsigned long long int ?+=?( unsigned long long int &, unsigned long long int ), ?+=?( volatile unsigned long long int &, unsigned long long int ); + +_Bool ?-=?( _Bool &, _Bool ), ?-=?( volatile _Bool &, _Bool ); +char ?-=?( char &, char ), ?-=?( volatile char &, char ); +char signed ?-=?( char signed &, char signed ), ?-=?( volatile char signed &, char signed ); +char unsigned ?-=?( char unsigned &, char unsigned ), ?-=?( volatile char unsigned &, char unsigned ); +int short ?-=?( int short &, int short ), ?-=?( volatile int short &, int short ); +int short unsigned ?-=?( int short unsigned &, int short unsigned ), ?-=?( volatile int short unsigned &, int short unsigned ); +signed int ?-=?( signed int &, signed int ), ?-=?( volatile signed int &, signed int ); +unsigned int ?-=?( unsigned &, unsigned ), ?-=?( volatile unsigned &, unsigned ); +signed long int ?-=?( signed long int &, signed long int ), ?-=?( volatile signed long int &, signed long int ); +unsigned long int ?-=?( unsigned long int &, unsigned long int ), ?-=?( volatile unsigned long int &, unsigned long int ); +signed long long int ?-=?( signed long long int &, signed long long int ), ?-=?( volatile signed long long int &, signed long long int ); +unsigned long long int ?-=?( unsigned long long int &, unsigned long long int ), ?-=?( volatile unsigned long long int &, unsigned long long int ); + +_Bool ?<<=?( _Bool &, _Bool ), ?<<=?( volatile _Bool &, _Bool ); +char ?<<=?( char &, char ), ?<<=?( volatile char &, char ); +char signed ?<<=?( char signed &, char signed ), ?<<=?( volatile char signed &, char signed ); +char unsigned ?<<=?( char unsigned &, char unsigned ), ?<<=?( volatile char unsigned &, char unsigned ); +int short ?<<=?( int short &, int short ), ?<<=?( volatile int short &, int short ); +int short unsigned ?<<=?( int short unsigned &, int short unsigned ), ?<<=?( volatile int short unsigned &, int short unsigned ); +signed int ?<<=?( signed int &, signed int ), ?<<=?( volatile signed int &, signed int ); +unsigned int ?<<=?( unsigned &, unsigned ), ?<<=?( volatile unsigned &, unsigned ); +signed long int ?<<=?( signed long int &, signed long int ), ?<<=?( volatile signed long int &, signed long int ); +unsigned long int ?<<=?( unsigned long int &, unsigned long int ), ?<<=?( volatile unsigned long int &, unsigned long int ); +signed long long int ?<<=?( signed long long int &, signed long long int ), ?<<=?( volatile signed long long int &, signed long long int ); +unsigned long long int ?<<=?( unsigned long long int &, unsigned long long int ), ?<<=?( volatile unsigned long long int &, unsigned long long int ); + +_Bool ?>>=?( _Bool &, _Bool ), ?>>=?( volatile _Bool &, _Bool ); +char ?>>=?( char &, char ), ?>>=?( volatile char &, char ); +char signed ?>>=?( char signed &, char signed ), ?>>=?( volatile char signed &, char signed ); +char unsigned ?>>=?( char unsigned &, char unsigned ), ?>>=?( volatile char unsigned &, char unsigned ); +int short ?>>=?( int short &, int short ), ?>>=?( volatile int short &, int short ); +int short unsigned ?>>=?( int short unsigned &, int short unsigned ), ?>>=?( volatile int short unsigned &, int short unsigned ); +signed int ?>>=?( signed int &, signed int ), ?>>=?( volatile signed int &, signed int ); +unsigned int ?>>=?( unsigned &, unsigned ), ?>>=?( volatile unsigned &, unsigned ); +signed long int ?>>=?( signed long int &, signed long int ), ?>>=?( volatile signed long int &, signed long int ); +unsigned long int ?>>=?( unsigned long int &, unsigned long int ), ?>>=?( volatile unsigned long int &, unsigned long int ); +signed long long int ?>>=?( signed long long int &, signed long long int ), ?>>=?( volatile signed long long int &, signed long long int ); +unsigned long long int ?>>=?( unsigned long long int &, unsigned long long int ), ?>>=?( volatile unsigned long long int &, unsigned long long int ); + +_Bool ?&=?( _Bool &, _Bool ), ?&=?( volatile _Bool &, _Bool ); +char ?&=?( char &, char ), ?&=?( volatile char &, char ); +char signed ?&=?( char signed &, char signed ), ?&=?( volatile char signed &, char signed ); +char unsigned ?&=?( char unsigned &, char unsigned ), ?&=?( volatile char unsigned &, char unsigned ); +int short ?&=?( int short &, int short ), ?&=?( volatile int short &, int short ); +int short unsigned ?&=?( int short unsigned &, int short unsigned ), ?&=?( volatile int short unsigned &, int short unsigned ); +signed int ?&=?( signed int &, signed int ), ?&=?( volatile signed int &, signed int ); +unsigned int ?&=?( unsigned &, unsigned ), ?&=?( volatile unsigned &, unsigned ); +signed long int ?&=?( signed long int &, signed long int ), ?&=?( volatile signed long int &, signed long int ); +unsigned long int ?&=?( unsigned long int &, unsigned long int ), ?&=?( volatile unsigned long int &, unsigned long int ); +signed long long int ?&=?( signed long long int &, signed long long int ), ?&=?( volatile signed long long int &, signed long long int ); +unsigned long long int ?&=?( unsigned long long int &, unsigned long long int ), ?&=?( volatile unsigned long long int &, unsigned long long int ); + +_Bool ?|=?( _Bool &, _Bool ), ?|=?( volatile _Bool &, _Bool ); +char ?|=?( char &, char ), ?|=?( volatile char &, char ); +char signed ?|=?( char signed &, char signed ), ?|=?( volatile char signed &, char signed ); +char unsigned ?|=?( char unsigned &, char unsigned ), ?|=?( volatile char unsigned &, char unsigned ); +int short ?|=?( int short &, int short ), ?|=?( volatile int short &, int short ); +int short unsigned ?|=?( int short unsigned &, int short unsigned ), ?|=?( volatile int short unsigned &, int short unsigned ); +signed int ?|=?( signed int &, signed int ), ?|=?( volatile signed int &, signed int ); +unsigned int ?|=?( unsigned &, unsigned ), ?|=?( volatile unsigned &, unsigned ); +signed long int ?|=?( signed long int &, signed long int ), ?|=?( volatile signed long int &, signed long int ); +unsigned long int ?|=?( unsigned long int &, unsigned long int ), ?|=?( volatile unsigned long int &, unsigned long int ); +signed long long int ?|=?( signed long long int &, signed long long int ), ?|=?( volatile signed long long int &, signed long long int ); +unsigned long long int ?|=?( unsigned long long int &, unsigned long long int ), ?|=?( volatile unsigned long long int &, unsigned long long int ); + +_Bool ?^=?( _Bool &, _Bool ), ?^=?( volatile _Bool &, _Bool ); +char ?^=?( char &, char ), ?^=?( volatile char &, char ); +char signed ?^=?( char signed &, char signed ), ?^=?( volatile char signed &, char signed ); +char unsigned ?^=?( char unsigned &, char unsigned ), ?^=?( volatile char unsigned &, char unsigned ); +int short ?^=?( int short &, int short ), ?^=?( volatile int short &, int short ); +int short unsigned ?^=?( int short unsigned &, int short unsigned ), ?^=?( volatile int short unsigned &, int short unsigned ); +signed int ?^=?( signed int &, signed int ), ?^=?( volatile signed int &, signed int ); +unsigned int ?^=?( unsigned &, unsigned ), ?^=?( volatile unsigned &, unsigned ); +signed long int ?^=?( signed long int &, signed long int ), ?^=?( volatile signed long int &, signed long int ); +unsigned long int ?^=?( unsigned long int &, unsigned long int ), ?^=?( volatile unsigned long int &, unsigned long int ); +signed long long int ?^=?( signed long long int &, signed long long int ), ?^=?( volatile signed long long int &, signed long long int ); +unsigned long long int ?^=?( unsigned long long int &, unsigned long long int ), ?^=?( volatile unsigned long long int &, unsigned long long int ); + +float ?=?( float &, float ), ?=?( volatile float &, float ), + ?*=?( float &, float ), ?*=?( volatile float &, float ), + ?/=?( float &, float ), ?/=?( volatile float &, float ), + ?+=?( float &, float ), ?+=?( volatile float &, float ), + ?-=?( float &, float ), ?-=?( volatile float &, float ); + +double ?=?( double &, double ), ?=?( volatile double &, double ), + ?*=?( double &, double ), ?*=?( volatile double &, double ), + ?/=?( double &, double ), ?/=?( volatile double &, double ), + ?+=?( double &, double ), ?+=?( volatile double &, double ), + ?-=?( double &, double ), ?-=?( volatile double &, double ); + +long double ?=?( long double &, long double ), ?=?( volatile long double &, long double ), + ?*=?( long double &, long double ), ?*=?( volatile long double &, long double ), + ?/=?( long double &, long double ), ?/=?( volatile long double &, long double ), + ?+=?( long double &, long double ), ?+=?( volatile long double &, long double ), + ?-=?( long double &, long double ), ?-=?( volatile long double &, long double ); + +float _Complex ?=?( float _Complex &, float _Complex ), ?=?( volatile float _Complex &, float _Complex ), + ?*=?( float _Complex &, float _Complex ), ?*=?( volatile float _Complex &, float _Complex ), + ?/=?( float _Complex &, float _Complex ), ?/=?( volatile float _Complex &, float _Complex ), + ?+=?( float _Complex &, float _Complex ), ?+=?( volatile float _Complex &, float _Complex ), + ?-=?( float _Complex &, float _Complex ), ?-=?( volatile float _Complex &, float _Complex ); + +double _Complex ?=?( double _Complex &, double _Complex ), ?=?( volatile double _Complex &, double _Complex ), + ?*=?( double _Complex &, double _Complex ), ?*=?( volatile double _Complex &, double _Complex ), + ?/=?( double _Complex &, double _Complex ), ?/=?( volatile double _Complex &, double _Complex ), + ?+=?( double _Complex &, double _Complex ), ?+=?( volatile double _Complex &, double _Complex ), + ?-=?( double _Complex &, double _Complex ), ?-=?( volatile double _Complex &, double _Complex ); + +long double _Complex ?=?( 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 ), + ?/=?( 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 ), + ?-=?( long double _Complex &, long double _Complex ), ?-=?( volatile long double _Complex &, long double _Complex ); @@ -669,68 +669,68 @@ // default ctor -void ?{}( _Bool * ); -void ?{}( char * ); -void ?{}( unsigned char * ); -void ?{}( char signed * ); -void ?{}( int short * ); -void ?{}( int short unsigned * ); -void ?{}( signed int * ); -void ?{}( unsigned int * ); -void ?{}( signed long int * ); -void ?{}( unsigned long int * ); -void ?{}( signed long long int * ); -void ?{}( unsigned long long int * ); -void ?{}( float * ); -void ?{}( double * ); -void ?{}( long double * ); -void ?{}( float _Complex * ); -void ?{}( double _Complex * ); -void ?{}( long double _Complex * ); -void ?{}( zero_t * ); -void ?{}( one_t * ); +void ?{}( _Bool & ); +void ?{}( char & ); +void ?{}( unsigned char & ); +void ?{}( char signed & ); +void ?{}( int short & ); +void ?{}( int short unsigned & ); +void ?{}( signed int & ); +void ?{}( unsigned int & ); +void ?{}( signed long int & ); +void ?{}( unsigned long int & ); +void ?{}( signed long long int & ); +void ?{}( unsigned long long int & ); +void ?{}( float & ); +void ?{}( double & ); +void ?{}( long double & ); +void ?{}( float _Complex & ); +void ?{}( double _Complex & ); +void ?{}( long double _Complex & ); +void ?{}( zero_t & ); +void ?{}( one_t & ); // copy ctor -void ?{}( _Bool *, _Bool ); -void ?{}( char *, char ); -void ?{}( unsigned char *, unsigned char ); -void ?{}( char signed *, char signed ); -void ?{}( int short *, int short ); -void ?{}( int short unsigned *, int short unsigned ); -void ?{}( signed int *, signed int); -void ?{}( unsigned int *, unsigned int); -void ?{}( signed long int *, signed long int); -void ?{}( unsigned long int *, unsigned long int); -void ?{}( signed long long int *, signed long long int); -void ?{}( unsigned long long int *, unsigned long long int); -void ?{}( float *, float); -void ?{}( double *, double); -void ?{}( long double *, long double); -void ?{}( float _Complex *, float _Complex); -void ?{}( double _Complex *, double _Complex); -void ?{}( long double _Complex *, long double _Complex); -void ?{}( zero_t *, zero_t ); -void ?{}( one_t *, one_t ); +void ?{}( _Bool &, _Bool ); +void ?{}( char &, char ); +void ?{}( unsigned char &, unsigned char ); +void ?{}( char signed &, char signed ); +void ?{}( int short &, int short ); +void ?{}( int short unsigned &, int short unsigned ); +void ?{}( signed int &, signed int); +void ?{}( unsigned int &, unsigned int); +void ?{}( signed long int &, signed long int); +void ?{}( unsigned long int &, unsigned long int); +void ?{}( signed long long int &, signed long long int); +void ?{}( unsigned long long int &, unsigned long long int); +void ?{}( float &, float); +void ?{}( double &, double); +void ?{}( long double &, long double); +void ?{}( float _Complex &, float _Complex); +void ?{}( double _Complex &, double _Complex); +void ?{}( long double _Complex &, long double _Complex); +void ?{}( zero_t &, zero_t ); +void ?{}( one_t &, one_t ); // dtor -void ^?{}( _Bool * ); -void ^?{}( char * ); -void ^?{}( char unsigned * ); -void ^?{}( char signed * ); -void ^?{}( int short * ); -void ^?{}( int short unsigned * ); -void ^?{}( signed int * ); -void ^?{}( unsigned int * ); -void ^?{}( signed long int * ); -void ^?{}( unsigned long int * ); -void ^?{}( signed long long int * ); -void ^?{}( unsigned long long int * ); -void ^?{}( float * ); -void ^?{}( double * ); -void ^?{}( long double * ); -void ^?{}( float _Complex * ); -void ^?{}( double _Complex * ); -void ^?{}( long double _Complex * ); -void ^?{}( zero_t * ); -void ^?{}( one_t * ); +void ^?{}( _Bool & ); +void ^?{}( char & ); +void ^?{}( char unsigned & ); +void ^?{}( char signed & ); +void ^?{}( int short & ); +void ^?{}( int short unsigned & ); +void ^?{}( signed int & ); +void ^?{}( unsigned int & ); +void ^?{}( signed long int & ); +void ^?{}( unsigned long int & ); +void ^?{}( signed long long int & ); +void ^?{}( unsigned long long int & ); +void ^?{}( float & ); +void ^?{}( double & ); +void ^?{}( long double & ); +void ^?{}( float _Complex & ); +void ^?{}( double _Complex & ); +void ^?{}( long double _Complex & ); +void ^?{}( zero_t & ); +void ^?{}( one_t & ); // // default ctor @@ -754,83 +754,83 @@ // 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 ?{}( const DT * *, DT * ); -forall( dtype DT ) void ?{}( const DT * *, const DT * ); -forall( dtype DT ) void ?{}( volatile DT * *, DT * ); -forall( dtype DT ) void ?{}( volatile DT * *, volatile DT * ); - -forall( dtype DT ) void ?{}( const volatile DT * *, DT * ); -forall( dtype DT ) void ?{}( const volatile DT * *, const DT * ); -forall( dtype DT ) void ?{}( const volatile DT * *, volatile DT * ); -forall( dtype DT ) void ?{}( const volatile DT * *, const volatile DT * ); - -forall( dtype DT ) void ?{}( DT * *, void * ); -forall( dtype DT ) void ?{}( const DT * *, void * ); -forall( dtype DT ) void ?{}( const DT * *, const void * ); -forall( dtype DT ) void ?{}( volatile DT * *, void * ); -forall( dtype DT ) void ?{}( volatile DT * *, volatile void * ); - -forall( dtype DT ) void ?{}( const volatile DT * *, void * ); -forall( dtype DT ) void ?{}( const volatile DT * *, const void * ); -forall( dtype DT ) void ?{}( const volatile DT * *, volatile void * ); -forall( dtype DT ) void ?{}( const volatile DT * *, const volatile void * ); - -forall( dtype DT ) void ?{}( void * *, DT * ); -forall( dtype DT ) void ?{}( const void * *, DT * ); -forall( dtype DT ) void ?{}( const void * *, const DT * ); -forall( dtype DT ) void ?{}( volatile void * *, DT * ); -forall( dtype DT ) void ?{}( volatile void * *, volatile DT * ); -forall( dtype DT ) void ?{}( const volatile void * *, DT * ); -forall( dtype DT ) void ?{}( const volatile void * *, const DT * ); -forall( dtype DT ) void ?{}( const volatile void * *, volatile DT * ); -forall( dtype DT ) void ?{}( const volatile void * *, const volatile DT * ); - -void ?{}( void * *, void * ); -void ?{}( const void * *, void * ); -void ?{}( const void * *, const void * ); -void ?{}( volatile void * *, void * ); -void ?{}( volatile void * *, volatile void * ); -void ?{}( const volatile void * *, void * ); -void ?{}( const volatile void * *, const void * ); -void ?{}( const volatile void * *, volatile void * ); -void ?{}( const volatile void * *, const volatile void * ); - -// //forall( dtype DT ) void ?{}( DT * *, zero_t ); -// //forall( dtype DT ) void ?{}( DT * volatile *, zero_t ); -// forall( dtype DT ) void ?{}( const DT * *, zero_t ); -// //forall( dtype DT ) void ?{}( volatile DT * *, zero_t ); -// //forall( dtype DT ) void ?{}( volatile DT * volatile *, zero_t ); -// forall( dtype DT ) void ?{}( const volatile DT * *, zero_t ); - -// forall( ftype FT ) void ?{}( FT * *, zero_t ); +forall( ftype FT ) void ?{}( FT *&, FT * ); +forall( ftype FT ) void ?{}( FT * volatile &, FT * ); + +forall( dtype DT ) void ?{}( DT * &, DT * ); +forall( dtype DT ) void ?{}( const DT * &, DT * ); +forall( dtype DT ) void ?{}( const DT * &, const DT * ); +forall( dtype DT ) void ?{}( volatile DT * &, DT * ); +forall( dtype DT ) void ?{}( volatile DT * &, volatile DT * ); + +forall( dtype DT ) void ?{}( const volatile DT * &, DT * ); +forall( dtype DT ) void ?{}( const volatile DT * &, const DT * ); +forall( dtype DT ) void ?{}( const volatile DT * &, volatile DT * ); +forall( dtype DT ) void ?{}( const volatile DT * &, const volatile DT * ); + +forall( dtype DT ) void ?{}( DT * &, void * ); +forall( dtype DT ) void ?{}( const DT * &, void * ); +forall( dtype DT ) void ?{}( const DT * &, const void * ); +forall( dtype DT ) void ?{}( volatile DT * &, void * ); +forall( dtype DT ) void ?{}( volatile DT * &, volatile void * ); + +forall( dtype DT ) void ?{}( const volatile DT * &, void * ); +forall( dtype DT ) void ?{}( const volatile DT * &, const void * ); +forall( dtype DT ) void ?{}( const volatile DT * &, volatile void * ); +forall( dtype DT ) void ?{}( const volatile DT * &, const volatile void * ); + +forall( dtype DT ) void ?{}( void * &, DT * ); +forall( dtype DT ) void ?{}( const void * &, DT * ); +forall( dtype DT ) void ?{}( const void * &, const DT * ); +forall( dtype DT ) void ?{}( volatile void * &, DT * ); +forall( dtype DT ) void ?{}( volatile void * &, volatile DT * ); +forall( dtype DT ) void ?{}( const volatile void * &, DT * ); +forall( dtype DT ) void ?{}( const volatile void * &, const DT * ); +forall( dtype DT ) void ?{}( const volatile void * &, volatile DT * ); +forall( dtype DT ) void ?{}( const volatile void * &, const volatile DT * ); + +void ?{}( void * &, void * ); +void ?{}( const void * &, void * ); +void ?{}( const void * &, const void * ); +void ?{}( volatile void * &, void * ); +void ?{}( volatile void * &, volatile void * ); +void ?{}( const volatile void * &, void * ); +void ?{}( const volatile void * &, const void * ); +void ?{}( const volatile void * &, volatile void * ); +void ?{}( const volatile void * &, const volatile void * ); + +//forall( dtype DT ) void ?{}( DT * &, zero_t ); +//forall( dtype DT ) void ?{}( DT * volatile &, zero_t ); +forall( dtype DT ) void ?{}( const DT * &, zero_t ); +//forall( dtype DT ) void ?{}( volatile DT * &, zero_t ); +//forall( dtype DT ) void ?{}( volatile DT * volatile &, zero_t ); +forall( dtype DT ) void ?{}( const volatile DT * &, zero_t ); + +forall( ftype FT ) void ?{}( FT * &, zero_t ); // default ctors -forall( ftype FT ) void ?{}( FT * * ); - -forall( dtype DT ) void ?{}( DT * *); -forall( dtype DT ) void ?{}( const DT * *); -forall( dtype DT ) void ?{}( volatile DT * *); -forall( dtype DT ) void ?{}( const volatile DT * *); - -void ?{}( void * *); -void ?{}( const void * *); -void ?{}( volatile void * *); -void ?{}( const volatile void * *); +forall( ftype FT ) void ?{}( FT * & ); + +forall( dtype DT ) void ?{}( DT * &); +forall( dtype DT ) void ?{}( const DT * &); +forall( dtype DT ) void ?{}( volatile DT * &); +forall( dtype DT ) void ?{}( const volatile DT * &); + +void ?{}( void * &); +void ?{}( const void * &); +void ?{}( volatile void * &); +void ?{}( const volatile void * &); // dtors -forall( ftype FT ) void ^?{}( FT * * ); - -forall( dtype DT ) void ^?{}( DT * *); -forall( dtype DT ) void ^?{}( const DT * *); -forall( dtype DT ) void ^?{}( volatile DT * *); -forall( dtype DT ) void ^?{}( const volatile DT * *); - -void ^?{}( void * *); -void ^?{}( const void * *); -void ^?{}( volatile void * *); -void ^?{}( const volatile void * *); +forall( ftype FT ) void ^?{}( FT * & ); + +forall( dtype DT ) void ^?{}( DT * &); +forall( dtype DT ) void ^?{}( const DT * &); +forall( dtype DT ) void ^?{}( volatile DT * &); +forall( dtype DT ) void ^?{}( const volatile DT * &); + +void ^?{}( void * &); +void ^?{}( const void * &); +void ^?{}( volatile void * &); +void ^?{}( const volatile void * &); // Local Variables: // Index: src/tests/.expect/64/KRfunctions.txt =================================================================== --- src/tests/.expect/64/KRfunctions.txt (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/.expect/64/KRfunctions.txt (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -17,25 +17,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1); -static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1); -static inline void ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1); -static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1); -static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){ - ((void)((*((int *)(&(*___dst__P2sS_1).__i__i_1)))) /* ?{} */); +static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1); +static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1); +static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1); +static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1); +static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){ + ((void)((*___dst__R2sS_1).__i__i_1) /* ?{} */); } -static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){ - ((void)((*((int *)(&(*___dst__P2sS_1).__i__i_1)))=___src__2sS_1.__i__i_1) /* ?{} */); +static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){ + ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */); } -static inline void ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){ - ((void)((*((int *)(&(*___dst__P2sS_1).__i__i_1)))) /* ^?{} */); +static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){ + ((void)((*___dst__R2sS_1).__i__i_1) /* ^?{} */); } -static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){ +static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){ struct S ___ret__2sS_1; - ((void)((*___dst__P2sS_1).__i__i_1=___src__2sS_1.__i__i_1)); - ((void)___constructor__F_P2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1)); + ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1)); + ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1)); return ((struct S )___ret__2sS_1); } -static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P2sS_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __i__i_1){ + ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */); } int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, int *__c__Pi_1){ @@ -88,6 +88,6 @@ int __b__i_2; int *(*_tmp_cp_ret0)(int __x__i_1, int __y__i_1); - ((void)(__x__PFPi_ii__2=((_tmp_cp_ret0=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5)) , _tmp_cp_ret0))); - ((void)((*((int *(**)(int __x__i_1, int __y__i_1))(&_tmp_cp_ret0)))) /* ^?{} */); + ((void)(__x__PFPi_ii__2=(((void)(_tmp_cp_ret0=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret0))); + ((void)(_tmp_cp_ret0) /* ^?{} */); const int __f1__FCi_iPiPi__2(int __a__i_2, int *__b__Pi_2, int *__c__Pi_2){ __attribute__ ((unused)) const int ___retval_f1__Ci_2; Index: src/tests/.expect/64/attributes.txt =================================================================== --- src/tests/.expect/64/attributes.txt (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/.expect/64/attributes.txt (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -11,17 +11,17 @@ __attribute__ ((unused)) struct __anonymous0 { }; -static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1); -static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1); -static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1); -static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1); -static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){ -} -static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){ -} -static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){ -} -static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){ +static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1); +static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1); +static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1); +static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1); +static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){ +} +static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){ +} +static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){ +} +static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){ struct __anonymous0 ___ret__13s__anonymous0_1; - ((void)___constructor__F_P13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1)); + ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1)); return ((struct __anonymous0 )___ret__13s__anonymous0_1); } @@ -29,17 +29,17 @@ __attribute__ ((unused)) struct Agn2 { }; -static inline void ___constructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1); -static inline void ___constructor__F_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1); -static inline void ___destructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1); -static inline struct Agn2 ___operator_assign__F5sAgn2_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1); -static inline void ___constructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1){ -} -static inline void ___constructor__F_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1){ -} -static inline void ___destructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1){ -} -static inline struct Agn2 ___operator_assign__F5sAgn2_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1){ +static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1); +static inline void ___constructor__F_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1); +static inline void ___destructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1); +static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1); +static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1){ +} +static inline void ___constructor__F_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){ +} +static inline void ___destructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1){ +} +static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){ struct Agn2 ___ret__5sAgn2_1; - ((void)___constructor__F_P5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1)); + ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1)); return ((struct Agn2 )___ret__5sAgn2_1); } @@ -65,153 +65,153 @@ __attribute__ ((unused,unused)) int *__f9__Pi_1; }; -static inline void ___constructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1); -static inline void ___constructor__F_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1); -static inline void ___destructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1); -static inline struct Fdl ___operator_assign__F4sFdl_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1); -static inline void ___constructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1){ - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */); - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */); -} -static inline void ___constructor__F_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1){ - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=___src__4sFdl_1.__f1__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=___src__4sFdl_1.__f2__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=___src__4sFdl_1.__f3__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=___src__4sFdl_1.__f4__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=___src__4sFdl_1.__f5__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=___src__4sFdl_1.__f6__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=___src__4sFdl_1.__f7__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))=___src__4sFdl_1.__f8__i_1) /* ?{} */); - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))=___src__4sFdl_1.__f9__Pi_1) /* ?{} */); -} -static inline void ___destructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1){ - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))) /* ^?{} */); -} -static inline struct Fdl ___operator_assign__F4sFdl_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1){ +static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1); +static inline void ___constructor__F_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1); +static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1); +static inline struct Fdl ___operator_assign__F4sFdl_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1); +static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){ + ((void)((*___dst__R4sFdl_1).__f1__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); +} +static inline void ___constructor__F_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1){ + ((void)((*___dst__R4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */); +} +static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){ + ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ^?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ^?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ^?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ^?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ^?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ^?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ^?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ^?{} */); + ((void)((*___dst__R4sFdl_1).__f1__i_1) /* ^?{} */); +} +static inline struct Fdl ___operator_assign__F4sFdl_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1){ struct Fdl ___ret__4sFdl_1; - ((void)((*___dst__P4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1)); - ((void)((*___dst__P4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1)); - ((void)((*___dst__P4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1)); - ((void)((*___dst__P4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1)); - ((void)((*___dst__P4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1)); - ((void)((*___dst__P4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1)); - ((void)((*___dst__P4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1)); - ((void)((*___dst__P4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1)); - ((void)((*___dst__P4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1)); - ((void)___constructor__F_P4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___src__4sFdl_1)); + ((void)((*___dst__R4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1)); + ((void)((*___dst__R4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1)); + ((void)((*___dst__R4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1)); + ((void)((*___dst__R4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1)); + ((void)((*___dst__R4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1)); + ((void)((*___dst__R4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1)); + ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1)); + ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1)); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1)); + ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___src__4sFdl_1)); return ((struct Fdl )___ret__4sFdl_1); } -static inline void ___constructor__F_P4sFdli_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1){ - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */); - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */); -} -static inline void ___constructor__F_P4sFdlii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1){ - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */); - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */); -} -static inline void ___constructor__F_P4sFdliii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1){ - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */); - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */); -} -static inline void ___constructor__F_P4sFdliiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1){ - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */); - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */); -} -static inline void ___constructor__F_P4sFdliiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1){ - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */); - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */); -} -static inline void ___constructor__F_P4sFdliiiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1){ - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */); - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */); -} -static inline void ___constructor__F_P4sFdliiiiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1){ - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=__f7__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */); - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */); -} -static inline void ___constructor__F_P4sFdliiiiiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1){ - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=__f7__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))=__f8__i_1) /* ?{} */); - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */); -} -static inline void ___constructor__F_P4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1, int *__f9__Pi_1){ - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=__f7__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))=__f8__i_1) /* ?{} */); - ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))=__f9__Pi_1) /* ?{} */); +static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1){ + ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); +} +static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1){ + ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); +} +static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1){ + ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); +} +static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1){ + ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); +} +static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1){ + ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); +} +static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1){ + ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); +} +static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1){ + ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); +} +static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1){ + ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); +} +static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1, int *__f9__Pi_1){ + ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */); + ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */); } __attribute__ ((unused)) int __f__Fi___1() asm ( "xyz" ); @@ -288,21 +288,21 @@ int __i__i_2; }; - inline void ___constructor__F_P13s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2){ - ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))) /* ?{} */); - } - inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){ - ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))=___src__13s__anonymous4_2.__i__i_2) /* ?{} */); - } - inline void ___destructor__F_P13s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2){ - ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))) /* ^?{} */); - } - inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){ + inline void ___constructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){ + ((void)((*___dst__R13s__anonymous4_2).__i__i_2) /* ?{} */); + } + inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){ + ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2) /* ?{} */); + } + inline void ___destructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){ + ((void)((*___dst__R13s__anonymous4_2).__i__i_2) /* ^?{} */); + } + inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){ struct __anonymous4 ___ret__13s__anonymous4_2; - ((void)((*___dst__P13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2)); - ((void)___constructor__F_P13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2)); + ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2)); + ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2)); return ((struct __anonymous4 )___ret__13s__anonymous4_2); } - inline void ___constructor__F_P13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, int __i__i_2){ - ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))=__i__i_2) /* ?{} */); + inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, int __i__i_2){ + ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */); } ((void)sizeof(struct __anonymous4 )); @@ -310,14 +310,14 @@ __R__C13e__anonymous5_2, }; - inline void ___constructor__F_P13e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2){ - } - inline void ___constructor__F_P13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){ - ((void)((*___dst__P13e__anonymous5_2)=___src__13e__anonymous5_2)); - } - inline void ___destructor__F_P13e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2){ - } - inline enum __anonymous5 ___operator_assign__F13e__anonymous5_P13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){ + inline void ___constructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_2){ + } + inline void ___constructor__F_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){ + ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2)); + } + inline void ___destructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_2){ + } + inline enum __anonymous5 ___operator_assign__F13e__anonymous5_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){ enum __anonymous5 ___ret__13e__anonymous5_2; - ((void)(___ret__13e__anonymous5_2=((*___dst__P13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */); + ((void)(___ret__13e__anonymous5_2=((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */); return ((enum __anonymous5 )___ret__13e__anonymous5_2); } @@ -337,17 +337,17 @@ __attribute__ ((unused,unused)) int (*__anonymous_object31)(); }; -static inline void ___constructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1); -static inline void ___constructor__F_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1); -static inline void ___destructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1); -static inline struct Vad ___operator_assign__F4sVad_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1); -static inline void ___constructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1){ -} -static inline void ___constructor__F_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1){ -} -static inline void ___destructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1){ -} -static inline struct Vad ___operator_assign__F4sVad_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1){ +static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1); +static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1); +static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1); +static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1); +static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){ +} +static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){ +} +static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){ +} +static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){ struct Vad ___ret__4sVad_1; - ((void)___constructor__F_P4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1)); + ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1)); return ((struct Vad )___ret__4sVad_1); } Index: src/tests/.expect/64/declarationSpecifier.txt =================================================================== --- src/tests/.expect/64/declarationSpecifier.txt (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/.expect/64/declarationSpecifier.txt (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -16,25 +16,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1); -static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1); -static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1); -static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1); -static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))=___src__13s__anonymous0_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){ +static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1); +static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1); +static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1); +static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1); +static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){ + ((void)((*___dst__R13s__anonymous0_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){ + ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){ + ((void)((*___dst__R13s__anonymous0_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){ struct __anonymous0 ___ret__13s__anonymous0_1; - ((void)((*___dst__P13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1)); - ((void)___constructor__F_P13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1)); + ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1)); + ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1)); return ((struct __anonymous0 )___ret__13s__anonymous0_1); } -static inline void ___constructor__F_P13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, int __i__i_1){ + ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */); } volatile const struct __anonymous0 __x10__CV13s__anonymous0_1; @@ -42,25 +42,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1); -static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1); -static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1); -static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1); -static inline void ___constructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))=___src__13s__anonymous1_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){ +static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1); +static inline void ___constructor__F_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1); +static inline void ___destructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1); +static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1); +static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1){ + ((void)((*___dst__R13s__anonymous1_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){ + ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1){ + ((void)((*___dst__R13s__anonymous1_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){ struct __anonymous1 ___ret__13s__anonymous1_1; - ((void)((*___dst__P13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1)); - ((void)___constructor__F_P13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1)); + ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1)); + ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1)); return ((struct __anonymous1 )___ret__13s__anonymous1_1); } -static inline void ___constructor__F_P13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, int __i__i_1){ + ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */); } volatile const struct __anonymous1 __x11__CV13s__anonymous1_1; @@ -68,25 +68,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1); -static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1); -static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1); -static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1); -static inline void ___constructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))=___src__13s__anonymous2_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){ +static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1); +static inline void ___constructor__F_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1); +static inline void ___destructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1); +static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1); +static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1){ + ((void)((*___dst__R13s__anonymous2_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){ + ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1){ + ((void)((*___dst__R13s__anonymous2_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){ struct __anonymous2 ___ret__13s__anonymous2_1; - ((void)((*___dst__P13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1)); - ((void)___constructor__F_P13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1)); + ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1)); + ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1)); return ((struct __anonymous2 )___ret__13s__anonymous2_1); } -static inline void ___constructor__F_P13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, int __i__i_1){ + ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */); } volatile const struct __anonymous2 __x12__CV13s__anonymous2_1; @@ -94,25 +94,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1); -static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1); -static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1); -static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1); -static inline void ___constructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))=___src__13s__anonymous3_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){ +static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1); +static inline void ___constructor__F_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1); +static inline void ___destructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1); +static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1); +static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1){ + ((void)((*___dst__R13s__anonymous3_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){ + ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1){ + ((void)((*___dst__R13s__anonymous3_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){ struct __anonymous3 ___ret__13s__anonymous3_1; - ((void)((*___dst__P13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1)); - ((void)___constructor__F_P13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1)); + ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1)); + ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1)); return ((struct __anonymous3 )___ret__13s__anonymous3_1); } -static inline void ___constructor__F_P13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, int __i__i_1){ + ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */); } static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1; @@ -120,25 +120,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1); -static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1); -static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1); -static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1); -static inline void ___constructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))=___src__13s__anonymous4_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){ +static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1); +static inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1); +static inline void ___destructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1); +static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1); +static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1){ + ((void)((*___dst__R13s__anonymous4_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){ + ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1){ + ((void)((*___dst__R13s__anonymous4_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){ struct __anonymous4 ___ret__13s__anonymous4_1; - ((void)((*___dst__P13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1)); - ((void)___constructor__F_P13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1)); + ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1)); + ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1)); return ((struct __anonymous4 )___ret__13s__anonymous4_1); } -static inline void ___constructor__F_P13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, int __i__i_1){ + ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */); } static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1; @@ -146,25 +146,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1); -static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1); -static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1); -static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1); -static inline void ___constructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))=___src__13s__anonymous5_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){ +static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1); +static inline void ___constructor__F_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1); +static inline void ___destructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1); +static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1); +static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1){ + ((void)((*___dst__R13s__anonymous5_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){ + ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1){ + ((void)((*___dst__R13s__anonymous5_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){ struct __anonymous5 ___ret__13s__anonymous5_1; - ((void)((*___dst__P13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1)); - ((void)___constructor__F_P13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1)); + ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1)); + ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1)); return ((struct __anonymous5 )___ret__13s__anonymous5_1); } -static inline void ___constructor__F_P13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, int __i__i_1){ + ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */); } static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1; @@ -172,25 +172,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1); -static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1); -static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1); -static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1); -static inline void ___constructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))=___src__13s__anonymous6_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){ +static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1); +static inline void ___constructor__F_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1); +static inline void ___destructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1); +static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1); +static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1){ + ((void)((*___dst__R13s__anonymous6_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){ + ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1){ + ((void)((*___dst__R13s__anonymous6_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){ struct __anonymous6 ___ret__13s__anonymous6_1; - ((void)((*___dst__P13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1)); - ((void)___constructor__F_P13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1)); + ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1)); + ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1)); return ((struct __anonymous6 )___ret__13s__anonymous6_1); } -static inline void ___constructor__F_P13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, int __i__i_1){ + ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */); } static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1; @@ -198,25 +198,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1); -static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1); -static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1); -static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1); -static inline void ___constructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))=___src__13s__anonymous7_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){ +static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1); +static inline void ___constructor__F_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1); +static inline void ___destructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1); +static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1); +static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1){ + ((void)((*___dst__R13s__anonymous7_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){ + ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1){ + ((void)((*___dst__R13s__anonymous7_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){ struct __anonymous7 ___ret__13s__anonymous7_1; - ((void)((*___dst__P13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1)); - ((void)___constructor__F_P13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1)); + ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1)); + ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1)); return ((struct __anonymous7 )___ret__13s__anonymous7_1); } -static inline void ___constructor__F_P13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, int __i__i_1){ + ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */); } static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1; @@ -232,25 +232,25 @@ short __i__s_1; }; -static inline void ___constructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1); -static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1); -static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1); -static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1); -static inline void ___constructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){ - ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ?{} */); -} -static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){ - ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))=___src__13s__anonymous8_1.__i__s_1) /* ?{} */); -} -static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){ - ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ^?{} */); -} -static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){ +static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1); +static inline void ___constructor__F_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1); +static inline void ___destructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1); +static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1); +static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1){ + ((void)((*___dst__R13s__anonymous8_1).__i__s_1) /* ?{} */); +} +static inline void ___constructor__F_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){ + ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1) /* ?{} */); +} +static inline void ___destructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1){ + ((void)((*___dst__R13s__anonymous8_1).__i__s_1) /* ^?{} */); +} +static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){ struct __anonymous8 ___ret__13s__anonymous8_1; - ((void)((*___dst__P13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1)); - ((void)___constructor__F_P13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1)); + ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1)); + ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1)); return ((struct __anonymous8 )___ret__13s__anonymous8_1); } -static inline void ___constructor__F_P13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, short __i__s_1){ - ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))=__i__s_1) /* ?{} */); +static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, short __i__s_1){ + ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */); } volatile const struct __anonymous8 __x29__CV13s__anonymous8_1; @@ -258,25 +258,25 @@ short __i__s_1; }; -static inline void ___constructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1); -static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1); -static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1); -static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1); -static inline void ___constructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){ - ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ?{} */); -} -static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){ - ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))=___src__13s__anonymous9_1.__i__s_1) /* ?{} */); -} -static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){ - ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ^?{} */); -} -static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){ +static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1); +static inline void ___constructor__F_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1); +static inline void ___destructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1); +static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1); +static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1){ + ((void)((*___dst__R13s__anonymous9_1).__i__s_1) /* ?{} */); +} +static inline void ___constructor__F_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){ + ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1) /* ?{} */); +} +static inline void ___destructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1){ + ((void)((*___dst__R13s__anonymous9_1).__i__s_1) /* ^?{} */); +} +static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){ struct __anonymous9 ___ret__13s__anonymous9_1; - ((void)((*___dst__P13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1)); - ((void)___constructor__F_P13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1)); + ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1)); + ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1)); return ((struct __anonymous9 )___ret__13s__anonymous9_1); } -static inline void ___constructor__F_P13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, short __i__s_1){ - ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))=__i__s_1) /* ?{} */); +static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, short __i__s_1){ + ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */); } volatile const struct __anonymous9 __x30__CV13s__anonymous9_1; @@ -284,25 +284,25 @@ short __i__s_1; }; -static inline void ___constructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1); -static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1); -static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1); -static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1); -static inline void ___constructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))=___src__14s__anonymous10_1.__i__s_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ^?{} */); -} -static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){ +static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1); +static inline void ___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1); +static inline void ___destructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1); +static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1); +static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1){ + ((void)((*___dst__R14s__anonymous10_1).__i__s_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){ + ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1){ + ((void)((*___dst__R14s__anonymous10_1).__i__s_1) /* ^?{} */); +} +static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){ struct __anonymous10 ___ret__14s__anonymous10_1; - ((void)((*___dst__P14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1)); - ((void)___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1)); + ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1)); + ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1)); return ((struct __anonymous10 )___ret__14s__anonymous10_1); } -static inline void ___constructor__F_P14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, short __i__s_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))=__i__s_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, short __i__s_1){ + ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */); } volatile const struct __anonymous10 __x31__CV14s__anonymous10_1; @@ -310,25 +310,25 @@ short __i__s_1; }; -static inline void ___constructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1); -static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1); -static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1); -static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1); -static inline void ___constructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))=___src__14s__anonymous11_1.__i__s_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ^?{} */); -} -static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){ +static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1); +static inline void ___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1); +static inline void ___destructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1); +static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1); +static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1){ + ((void)((*___dst__R14s__anonymous11_1).__i__s_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){ + ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1){ + ((void)((*___dst__R14s__anonymous11_1).__i__s_1) /* ^?{} */); +} +static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){ struct __anonymous11 ___ret__14s__anonymous11_1; - ((void)((*___dst__P14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1)); - ((void)___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1)); + ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1)); + ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1)); return ((struct __anonymous11 )___ret__14s__anonymous11_1); } -static inline void ___constructor__F_P14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, short __i__s_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))=__i__s_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, short __i__s_1){ + ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */); } static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1; @@ -336,25 +336,25 @@ short __i__s_1; }; -static inline void ___constructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1); -static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1); -static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1); -static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1); -static inline void ___constructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))=___src__14s__anonymous12_1.__i__s_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ^?{} */); -} -static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){ +static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1); +static inline void ___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1); +static inline void ___destructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1); +static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1); +static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1){ + ((void)((*___dst__R14s__anonymous12_1).__i__s_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){ + ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1){ + ((void)((*___dst__R14s__anonymous12_1).__i__s_1) /* ^?{} */); +} +static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){ struct __anonymous12 ___ret__14s__anonymous12_1; - ((void)((*___dst__P14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1)); - ((void)___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1)); + ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1)); + ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1)); return ((struct __anonymous12 )___ret__14s__anonymous12_1); } -static inline void ___constructor__F_P14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, short __i__s_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))=__i__s_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, short __i__s_1){ + ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */); } static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1; @@ -362,25 +362,25 @@ short __i__s_1; }; -static inline void ___constructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1); -static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1); -static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1); -static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1); -static inline void ___constructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))=___src__14s__anonymous13_1.__i__s_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ^?{} */); -} -static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){ +static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1); +static inline void ___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1); +static inline void ___destructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1); +static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1); +static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1){ + ((void)((*___dst__R14s__anonymous13_1).__i__s_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){ + ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1){ + ((void)((*___dst__R14s__anonymous13_1).__i__s_1) /* ^?{} */); +} +static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){ struct __anonymous13 ___ret__14s__anonymous13_1; - ((void)((*___dst__P14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1)); - ((void)___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1)); + ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1)); + ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1)); return ((struct __anonymous13 )___ret__14s__anonymous13_1); } -static inline void ___constructor__F_P14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, short __i__s_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))=__i__s_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, short __i__s_1){ + ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */); } static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1; @@ -388,25 +388,25 @@ short __i__s_1; }; -static inline void ___constructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1); -static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1); -static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1); -static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1); -static inline void ___constructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))=___src__14s__anonymous14_1.__i__s_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ^?{} */); -} -static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){ +static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1); +static inline void ___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1); +static inline void ___destructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1); +static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1); +static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1){ + ((void)((*___dst__R14s__anonymous14_1).__i__s_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){ + ((void)((*___dst__R14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1){ + ((void)((*___dst__R14s__anonymous14_1).__i__s_1) /* ^?{} */); +} +static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){ struct __anonymous14 ___ret__14s__anonymous14_1; - ((void)((*___dst__P14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1)); - ((void)___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1)); + ((void)((*___dst__R14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1)); + ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1)); return ((struct __anonymous14 )___ret__14s__anonymous14_1); } -static inline void ___constructor__F_P14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, short __i__s_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))=__i__s_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, short __i__s_1){ + ((void)((*___dst__R14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */); } static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1; @@ -414,25 +414,25 @@ short __i__s_1; }; -static inline void ___constructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1); -static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1); -static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1); -static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1); -static inline void ___constructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))=___src__14s__anonymous15_1.__i__s_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ^?{} */); -} -static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){ +static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1); +static inline void ___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1); +static inline void ___destructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1); +static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1); +static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1){ + ((void)((*___dst__R14s__anonymous15_1).__i__s_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){ + ((void)((*___dst__R14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1){ + ((void)((*___dst__R14s__anonymous15_1).__i__s_1) /* ^?{} */); +} +static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){ struct __anonymous15 ___ret__14s__anonymous15_1; - ((void)((*___dst__P14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1)); - ((void)___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1)); + ((void)((*___dst__R14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1)); + ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1)); return ((struct __anonymous15 )___ret__14s__anonymous15_1); } -static inline void ___constructor__F_P14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, short __i__s_1){ - ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))=__i__s_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, short __i__s_1){ + ((void)((*___dst__R14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */); } static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1; @@ -456,25 +456,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1); -static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1); -static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1); -static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1); -static inline void ___constructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))=___src__14s__anonymous16_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){ +static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1); +static inline void ___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1); +static inline void ___destructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1); +static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1); +static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1){ + ((void)((*___dst__R14s__anonymous16_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){ + ((void)((*___dst__R14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1){ + ((void)((*___dst__R14s__anonymous16_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){ struct __anonymous16 ___ret__14s__anonymous16_1; - ((void)((*___dst__P14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1)); - ((void)___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1)); + ((void)((*___dst__R14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1)); + ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1)); return ((struct __anonymous16 )___ret__14s__anonymous16_1); } -static inline void ___constructor__F_P14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, int __i__i_1){ + ((void)((*___dst__R14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */); } static inline volatile const struct __anonymous16 __f31__FCV14s__anonymous16___1(); @@ -482,25 +482,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1); -static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1); -static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1); -static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1); -static inline void ___constructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))=___src__14s__anonymous17_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){ +static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1); +static inline void ___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1); +static inline void ___destructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1); +static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1); +static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1){ + ((void)((*___dst__R14s__anonymous17_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){ + ((void)((*___dst__R14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1){ + ((void)((*___dst__R14s__anonymous17_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){ struct __anonymous17 ___ret__14s__anonymous17_1; - ((void)((*___dst__P14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1)); - ((void)___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1)); + ((void)((*___dst__R14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1)); + ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1)); return ((struct __anonymous17 )___ret__14s__anonymous17_1); } -static inline void ___constructor__F_P14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, int __i__i_1){ + ((void)((*___dst__R14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */); } static inline volatile const struct __anonymous17 __f32__FCV14s__anonymous17___1(); @@ -508,25 +508,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1); -static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1); -static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1); -static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1); -static inline void ___constructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))=___src__14s__anonymous18_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){ +static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1); +static inline void ___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1); +static inline void ___destructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1); +static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1); +static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1){ + ((void)((*___dst__R14s__anonymous18_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){ + ((void)((*___dst__R14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1){ + ((void)((*___dst__R14s__anonymous18_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){ struct __anonymous18 ___ret__14s__anonymous18_1; - ((void)((*___dst__P14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1)); - ((void)___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1)); + ((void)((*___dst__R14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1)); + ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1)); return ((struct __anonymous18 )___ret__14s__anonymous18_1); } -static inline void ___constructor__F_P14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, int __i__i_1){ + ((void)((*___dst__R14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */); } static inline volatile const struct __anonymous18 __f33__FCV14s__anonymous18___1(); @@ -534,25 +534,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1); -static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1); -static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1); -static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1); -static inline void ___constructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))=___src__14s__anonymous19_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){ +static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1); +static inline void ___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1); +static inline void ___destructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1); +static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1); +static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1){ + ((void)((*___dst__R14s__anonymous19_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){ + ((void)((*___dst__R14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1){ + ((void)((*___dst__R14s__anonymous19_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){ struct __anonymous19 ___ret__14s__anonymous19_1; - ((void)((*___dst__P14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1)); - ((void)___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1)); + ((void)((*___dst__R14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1)); + ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1)); return ((struct __anonymous19 )___ret__14s__anonymous19_1); } -static inline void ___constructor__F_P14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, int __i__i_1){ + ((void)((*___dst__R14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */); } static inline volatile const struct __anonymous19 __f34__FCV14s__anonymous19___1(); @@ -560,25 +560,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1); -static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1); -static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1); -static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1); -static inline void ___constructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))=___src__14s__anonymous20_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){ +static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1); +static inline void ___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1); +static inline void ___destructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1); +static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1); +static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1){ + ((void)((*___dst__R14s__anonymous20_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){ + ((void)((*___dst__R14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1){ + ((void)((*___dst__R14s__anonymous20_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){ struct __anonymous20 ___ret__14s__anonymous20_1; - ((void)((*___dst__P14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1)); - ((void)___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1)); + ((void)((*___dst__R14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1)); + ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1)); return ((struct __anonymous20 )___ret__14s__anonymous20_1); } -static inline void ___constructor__F_P14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, int __i__i_1){ + ((void)((*___dst__R14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */); } static inline volatile const struct __anonymous20 __f35__FCV14s__anonymous20___1(); @@ -586,25 +586,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1); -static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1); -static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1); -static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1); -static inline void ___constructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))=___src__14s__anonymous21_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){ +static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1); +static inline void ___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1); +static inline void ___destructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1); +static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1); +static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1){ + ((void)((*___dst__R14s__anonymous21_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){ + ((void)((*___dst__R14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1){ + ((void)((*___dst__R14s__anonymous21_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){ struct __anonymous21 ___ret__14s__anonymous21_1; - ((void)((*___dst__P14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1)); - ((void)___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1)); + ((void)((*___dst__R14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1)); + ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1)); return ((struct __anonymous21 )___ret__14s__anonymous21_1); } -static inline void ___constructor__F_P14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, int __i__i_1){ + ((void)((*___dst__R14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */); } static inline volatile const struct __anonymous21 __f36__FCV14s__anonymous21___1(); @@ -612,25 +612,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1); -static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1); -static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1); -static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1); -static inline void ___constructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))=___src__14s__anonymous22_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){ +static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1); +static inline void ___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1); +static inline void ___destructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1); +static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1); +static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1){ + ((void)((*___dst__R14s__anonymous22_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){ + ((void)((*___dst__R14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1){ + ((void)((*___dst__R14s__anonymous22_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){ struct __anonymous22 ___ret__14s__anonymous22_1; - ((void)((*___dst__P14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1)); - ((void)___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1)); + ((void)((*___dst__R14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1)); + ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1)); return ((struct __anonymous22 )___ret__14s__anonymous22_1); } -static inline void ___constructor__F_P14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, int __i__i_1){ + ((void)((*___dst__R14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */); } static inline volatile const struct __anonymous22 __f37__FCV14s__anonymous22___1(); @@ -638,25 +638,25 @@ int __i__i_1; }; -static inline void ___constructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1); -static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1); -static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1); -static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1); -static inline void ___constructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ?{} */); -} -static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))=___src__14s__anonymous23_1.__i__i_1) /* ?{} */); -} -static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ^?{} */); -} -static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){ +static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1); +static inline void ___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1); +static inline void ___destructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1); +static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1); +static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1){ + ((void)((*___dst__R14s__anonymous23_1).__i__i_1) /* ?{} */); +} +static inline void ___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){ + ((void)((*___dst__R14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1) /* ?{} */); +} +static inline void ___destructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1){ + ((void)((*___dst__R14s__anonymous23_1).__i__i_1) /* ^?{} */); +} +static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){ struct __anonymous23 ___ret__14s__anonymous23_1; - ((void)((*___dst__P14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1)); - ((void)___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1)); + ((void)((*___dst__R14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1)); + ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1)); return ((struct __anonymous23 )___ret__14s__anonymous23_1); } -static inline void ___constructor__F_P14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, int __i__i_1){ - ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))=__i__i_1) /* ?{} */); +static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, int __i__i_1){ + ((void)((*___dst__R14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */); } static inline volatile const struct __anonymous23 __f38__FCV14s__anonymous23___1(); @@ -687,6 +687,6 @@ __attribute__ ((unused)) int ___retval_main__i_1; int _tmp_cp_ret0; - ((void)(___retval_main__i_1=((_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1)) , _tmp_cp_ret0)) /* ?{} */); - ((void)((*((int *)(&_tmp_cp_ret0)))) /* ^?{} */); + ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */); + ((void)(_tmp_cp_ret0) /* ^?{} */); return ((int )___retval_main__i_1); } Index: src/tests/.expect/64/extension.txt =================================================================== --- src/tests/.expect/64/extension.txt (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/.expect/64/extension.txt (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -13,45 +13,45 @@ __extension__ int __c__i_1; }; -static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1); -static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1); -static inline void ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1); -static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1); -static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){ - ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))) /* ?{} */); +static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1); +static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1); +static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1); +static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1); +static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){ + ((void)((*___dst__R2sS_1).__a__i_1) /* ?{} */); + ((void)((*___dst__R2sS_1).__b__i_1) /* ?{} */); + ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */); } -static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){ - ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=___src__2sS_1.__a__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))=___src__2sS_1.__b__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))=___src__2sS_1.__c__i_1) /* ?{} */); +static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){ + ((void)((*___dst__R2sS_1).__a__i_1=___src__2sS_1.__a__i_1) /* ?{} */); + ((void)((*___dst__R2sS_1).__b__i_1=___src__2sS_1.__b__i_1) /* ?{} */); + ((void)((*___dst__R2sS_1).__c__i_1=___src__2sS_1.__c__i_1) /* ?{} */); } -static inline void ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){ - ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))) /* ^?{} */); +static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){ + ((void)((*___dst__R2sS_1).__c__i_1) /* ^?{} */); + ((void)((*___dst__R2sS_1).__b__i_1) /* ^?{} */); + ((void)((*___dst__R2sS_1).__a__i_1) /* ^?{} */); } -static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){ +static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){ struct S ___ret__2sS_1; - ((void)((*___dst__P2sS_1).__a__i_1=___src__2sS_1.__a__i_1)); - ((void)((*___dst__P2sS_1).__b__i_1=___src__2sS_1.__b__i_1)); - ((void)((*___dst__P2sS_1).__c__i_1=___src__2sS_1.__c__i_1)); - ((void)___constructor__F_P2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1)); + ((void)((*___dst__R2sS_1).__a__i_1=___src__2sS_1.__a__i_1)); + ((void)((*___dst__R2sS_1).__b__i_1=___src__2sS_1.__b__i_1)); + ((void)((*___dst__R2sS_1).__c__i_1=___src__2sS_1.__c__i_1)); + ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1)); return ((struct S )___ret__2sS_1); } -static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __a__i_1){ - ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=__a__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))) /* ?{} */); +static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __a__i_1){ + ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */); + ((void)((*___dst__R2sS_1).__b__i_1) /* ?{} */); + ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */); } -static inline void ___constructor__F_P2sSii_autogen___1(struct S *___dst__P2sS_1, int __a__i_1, int __b__i_1){ - ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=__a__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))=__b__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))) /* ?{} */); +static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1){ + ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */); + ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */); + ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */); } -static inline void ___constructor__F_P2sSiii_autogen___1(struct S *___dst__P2sS_1, int __a__i_1, int __b__i_1, int __c__i_1){ - ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=__a__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))=__b__i_1) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))=__c__i_1) /* ?{} */); +static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1, int __c__i_1){ + ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */); + ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */); + ((void)((*___dst__R2sS_1).__c__i_1=__c__i_1) /* ?{} */); } __extension__ union U { @@ -60,19 +60,19 @@ __extension__ int __c__i_1; }; -static inline void ___constructor__F_P2uU_autogen___1(union U *___dst__P2uU_1){ +static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){ } -static inline void ___constructor__F_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){ - ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U ))); +static inline void ___constructor__F_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1){ + ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U ))); } -static inline void ___destructor__F_P2uU_autogen___1(union U *___dst__P2uU_1){ +static inline void ___destructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){ } -static inline union U ___operator_assign__F2uU_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){ +static inline union U ___operator_assign__F2uU_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1){ union U ___ret__2uU_1; - ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U ))); - ((void)___constructor__F_P2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1)); + ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U ))); + ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1)); return ((union U )___ret__2uU_1); } -static inline void ___constructor__F_P2uUi_autogen___1(union U *___dst__P2uU_1, int __src__i_1){ - ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&__src__i_1)), sizeof(int ))); +static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, int __src__i_1){ + ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(int ))); } __extension__ enum E { @@ -102,6 +102,6 @@ ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2))); int _tmp_cp_ret0; - ((void)((_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3)) , _tmp_cp_ret0)); - ((void)((*((int *)(&_tmp_cp_ret0)))) /* ^?{} */); + ((void)(((void)(_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3))) , _tmp_cp_ret0)); + ((void)(_tmp_cp_ret0) /* ^?{} */); __extension__ int __mary__Fi_i__2(int __p__i_2){ __attribute__ ((unused)) int ___retval_mary__i_2; @@ -113,4 +113,4 @@ ((void)(((int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2)); ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2))); - ((void)((__extension__ __a__i_2 , __extension__ __b__i_2) , __extension__ __c__i_2)); + ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2)); } Index: src/tests/.expect/64/gccExtensions.txt =================================================================== --- src/tests/.expect/64/gccExtensions.txt (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/.expect/64/gccExtensions.txt (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -43,41 +43,41 @@ __extension__ int __c__i_2; }; - inline void ___constructor__F_P2sS_autogen___2(struct S *___dst__P2sS_2){ - ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))) /* ?{} */); + inline void ___constructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){ + ((void)((*___dst__R2sS_2).__a__i_2) /* ?{} */); + ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */); + ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */); } - inline void ___constructor__F_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){ - ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=___src__2sS_2.__a__i_2) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))=___src__2sS_2.__b__i_2) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))=___src__2sS_2.__c__i_2) /* ?{} */); + inline void ___constructor__F_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){ + ((void)((*___dst__R2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */); + ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */); + ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */); } - inline void ___destructor__F_P2sS_autogen___2(struct S *___dst__P2sS_2){ - ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))) /* ^?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))) /* ^?{} */); + inline void ___destructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){ + ((void)((*___dst__R2sS_2).__c__i_2) /* ^?{} */); + ((void)((*___dst__R2sS_2).__b__i_2) /* ^?{} */); + ((void)((*___dst__R2sS_2).__a__i_2) /* ^?{} */); } - inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){ + inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){ struct S ___ret__2sS_2; - ((void)((*___dst__P2sS_2).__a__i_2=___src__2sS_2.__a__i_2)); - ((void)((*___dst__P2sS_2).__b__i_2=___src__2sS_2.__b__i_2)); - ((void)((*___dst__P2sS_2).__c__i_2=___src__2sS_2.__c__i_2)); - ((void)___constructor__F_P2sS2sS_autogen___2((&___ret__2sS_2), ___src__2sS_2)); + ((void)((*___dst__R2sS_2).__a__i_2=___src__2sS_2.__a__i_2)); + ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2)); + ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2)); + ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), ___src__2sS_2)); return ((struct S )___ret__2sS_2); } - inline void ___constructor__F_P2sSi_autogen___2(struct S *___dst__P2sS_2, int __a__i_2){ - ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=__a__i_2) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))) /* ?{} */); + inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, int __a__i_2){ + ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */); + ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */); + ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */); } - inline void ___constructor__F_P2sSii_autogen___2(struct S *___dst__P2sS_2, int __a__i_2, int __b__i_2){ - ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=__a__i_2) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))=__b__i_2) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))) /* ?{} */); + inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2){ + ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */); + ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */); + ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */); } - inline void ___constructor__F_P2sSiii_autogen___2(struct S *___dst__P2sS_2, int __a__i_2, int __b__i_2, int __c__i_2){ - ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=__a__i_2) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))=__b__i_2) /* ?{} */); - ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))=__c__i_2) /* ?{} */); + inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2, int __c__i_2){ + ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */); + ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */); + ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */); } int __i__i_2 = ((int )__extension__ 3); @@ -85,5 +85,5 @@ __extension__ int __b__i_2; __extension__ int __c__i_2; - ((void)((__extension__ __a__i_2 , __extension__ __b__i_2) , __extension__ __c__i_2)); + ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2)); ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2))); ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2))); @@ -101,42 +101,42 @@ int __i__i_2; }; - inline void ___constructor__F_P3ss2_autogen___2(struct s2 *___dst__P3ss2_2){ - ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))) /* ?{} */); + inline void ___constructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){ + ((void)((*___dst__R3ss2_2).__i__i_2) /* ?{} */); } - inline void ___constructor__F_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){ - ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))=___src__3ss2_2.__i__i_2) /* ?{} */); + inline void ___constructor__F_R3ss23ss2_autogen___2(struct s2 *___dst__R3ss2_2, struct s2 ___src__3ss2_2){ + ((void)((*___dst__R3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2) /* ?{} */); } - inline void ___destructor__F_P3ss2_autogen___2(struct s2 *___dst__P3ss2_2){ - ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))) /* ^?{} */); + inline void ___destructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){ + ((void)((*___dst__R3ss2_2).__i__i_2) /* ^?{} */); } - inline struct s2 ___operator_assign__F3ss2_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){ + inline struct s2 ___operator_assign__F3ss2_R3ss23ss2_autogen___2(struct s2 *___dst__R3ss2_2, struct s2 ___src__3ss2_2){ struct s2 ___ret__3ss2_2; - ((void)((*___dst__P3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2)); - ((void)___constructor__F_P3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2)); + ((void)((*___dst__R3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2)); + ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2)); return ((struct s2 )___ret__3ss2_2); } - inline void ___constructor__F_P3ss2i_autogen___2(struct s2 *___dst__P3ss2_2, int __i__i_2){ - ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))=__i__i_2) /* ?{} */); + inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, int __i__i_2){ + ((void)((*___dst__R3ss2_2).__i__i_2=__i__i_2) /* ?{} */); } struct s3 { int __i__i_2; }; - inline void ___constructor__F_P3ss3_autogen___2(struct s3 *___dst__P3ss3_2){ - ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))) /* ?{} */); + inline void ___constructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){ + ((void)((*___dst__R3ss3_2).__i__i_2) /* ?{} */); } - inline void ___constructor__F_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){ - ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))=___src__3ss3_2.__i__i_2) /* ?{} */); + inline void ___constructor__F_R3ss33ss3_autogen___2(struct s3 *___dst__R3ss3_2, struct s3 ___src__3ss3_2){ + ((void)((*___dst__R3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2) /* ?{} */); } - inline void ___destructor__F_P3ss3_autogen___2(struct s3 *___dst__P3ss3_2){ - ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))) /* ^?{} */); + inline void ___destructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){ + ((void)((*___dst__R3ss3_2).__i__i_2) /* ^?{} */); } - inline struct s3 ___operator_assign__F3ss3_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){ + inline struct s3 ___operator_assign__F3ss3_R3ss33ss3_autogen___2(struct s3 *___dst__R3ss3_2, struct s3 ___src__3ss3_2){ struct s3 ___ret__3ss3_2; - ((void)((*___dst__P3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2)); - ((void)___constructor__F_P3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2)); + ((void)((*___dst__R3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2)); + ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2)); return ((struct s3 )___ret__3ss3_2); } - inline void ___constructor__F_P3ss3i_autogen___2(struct s3 *___dst__P3ss3_2, int __i__i_2){ - ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))=__i__i_2) /* ?{} */); + inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, int __i__i_2){ + ((void)((*___dst__R3ss3_2).__i__i_2=__i__i_2) /* ?{} */); } struct s3 __x1__3ss3_2; @@ -145,21 +145,21 @@ int __i__i_2; }; - inline void ___constructor__F_P3ss4_autogen___2(struct s4 *___dst__P3ss4_2){ - ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))) /* ?{} */); + inline void ___constructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){ + ((void)((*___dst__R3ss4_2).__i__i_2) /* ?{} */); } - inline void ___constructor__F_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){ - ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))=___src__3ss4_2.__i__i_2) /* ?{} */); + inline void ___constructor__F_R3ss43ss4_autogen___2(struct s4 *___dst__R3ss4_2, struct s4 ___src__3ss4_2){ + ((void)((*___dst__R3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2) /* ?{} */); } - inline void ___destructor__F_P3ss4_autogen___2(struct s4 *___dst__P3ss4_2){ - ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))) /* ^?{} */); + inline void ___destructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){ + ((void)((*___dst__R3ss4_2).__i__i_2) /* ^?{} */); } - inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){ + inline struct s4 ___operator_assign__F3ss4_R3ss43ss4_autogen___2(struct s4 *___dst__R3ss4_2, struct s4 ___src__3ss4_2){ struct s4 ___ret__3ss4_2; - ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2)); - ((void)___constructor__F_P3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2)); + ((void)((*___dst__R3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2)); + ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2)); return ((struct s4 )___ret__3ss4_2); } - inline void ___constructor__F_P3ss4i_autogen___2(struct s4 *___dst__P3ss4_2, int __i__i_2){ - ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))=__i__i_2) /* ?{} */); + inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, int __i__i_2){ + ((void)((*___dst__R3ss4_2).__i__i_2=__i__i_2) /* ?{} */); } struct s4 __x2__3ss4_2; @@ -184,6 +184,6 @@ __attribute__ ((unused)) int ___retval_main__i_1; int _tmp_cp_ret0; - ((void)(___retval_main__i_1=((_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1)) , _tmp_cp_ret0)) /* ?{} */); - ((void)((*((int *)(&_tmp_cp_ret0)))) /* ^?{} */); + ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */); + ((void)(_tmp_cp_ret0) /* ^?{} */); return ((int )___retval_main__i_1); } Index: src/tests/.expect/castError.txt =================================================================== --- src/tests/.expect/castError.txt (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/.expect/castError.txt (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -4,5 +4,5 @@ to: char -Alternatives are: Cost ( 1, 0, 0 ): Cast of: +Alternatives are: Cost ( 1, 0, 0, 0 ): Cast of: Variable Expression: f: function accepting unspecified arguments @@ -18,5 +18,5 @@ Environment: - Cost ( 1, 0, 0 ): Cast of: + Cost ( 1, 0, 0, 0 ): Cast of: Variable Expression: f: signed int @@ -28,5 +28,5 @@ Environment: - Cost ( 1, 0, 0 ): Cast of: + Cost ( 1, 0, 0, 0 ): Cast of: Variable Expression: f: double Index: src/tests/.expect/memberCtors-ERR1.txt =================================================================== --- src/tests/.expect/memberCtors-ERR1.txt (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/.expect/memberCtors-ERR1.txt (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -1,1 +1,1 @@ -memberCtors.c:71 error: in void ?{}(B *b), field a2 used before being constructed +memberCtors.c:71 error: in void ?{}(B &b), field a2 used before being constructed Index: src/tests/.expect/memberCtors.txt =================================================================== --- src/tests/.expect/memberCtors.txt (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/.expect/memberCtors.txt (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -7,19 +7,19 @@ constructing int begin construct B -assign b->a2 -constructing int -constructing int -begin construct A -construct a->x +assign b.a2 +constructing int +constructing int +begin construct A +construct a.x constructing int: 1001 -assign a->y -assigning int: 0 0 -end construct A -copy constructing int: 0 -copy constructing int: 0 -begin copy construct A -copy construct this->x -copy constructing int: 1001 -assign this->y +assign a.y +assigning int: 0 0 +end construct A +copy constructing int: 0 +copy constructing int: 0 +begin copy construct A +copy construct this.x +copy constructing int: 1001 +assign this.y copy constructing int: 0 destructing int: 0 @@ -40,24 +40,24 @@ copy constructing int: 0 begin copy construct A -copy construct this->x -copy constructing int: 1001 -assign this->y -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -end copy construct A -destructing int: 0 -destructing int: 0 -destructing int: 1001 -destructing int: 0 -destructing int: 0 -destructing int: 1001 -construct b->a1 -constructing int -constructing int -begin construct A -construct a->x +copy construct this.x +copy constructing int: 1001 +assign this.y +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +end copy construct A +destructing int: 0 +destructing int: 0 +destructing int: 1001 +destructing int: 0 +destructing int: 0 +destructing int: 1001 +construct b.a1 +constructing int +constructing int +begin construct A +construct a.x constructing int: 1000 -assign a->y +assign a.y assigning int: 0 0 end construct A @@ -70,27 +70,27 @@ copy constructing int: 0 begin copy construct A -copy construct this->x +copy construct this.x copy constructing int: 1000 -assign this->y -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -end copy construct A -copy constructing int: 0 -copy constructing int: 0 -begin copy construct A -copy construct this->x -copy constructing int: 1001 -assign this->y -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -end copy construct A -copy constructing int: 0 -copy constructing int: 0 -begin copy construct A -copy construct this->x -copy constructing int: 0 -assign this->y +assign this.y +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +end copy construct A +copy constructing int: 0 +copy constructing int: 0 +begin copy construct A +copy construct this.x +copy constructing int: 1001 +assign this.y +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +end copy construct A +copy constructing int: 0 +copy constructing int: 0 +begin copy construct A +copy construct this.x +copy constructing int: 0 +assign this.y copy constructing int: 0 destructing int: 0 @@ -101,15 +101,15 @@ constructing int begin construct A -construct a->x +construct a.x constructing int: 999 -assign a->y -assigning int: 0 0 -end construct A -copy constructing int: 0 -copy constructing int: 0 -begin copy construct A -copy construct this->x -copy constructing int: 999 -assign this->y +assign a.y +assigning int: 0 0 +end construct A +copy constructing int: 0 +copy constructing int: 0 +begin copy construct A +copy construct this.x +copy constructing int: 999 +assign this.y copy constructing int: 0 destructing int: 0 @@ -130,7 +130,7 @@ copy constructing int: 0 begin copy construct A -copy construct this->x -copy constructing int: 999 -assign this->y +copy construct this.x +copy constructing int: 999 +assign this.y copy constructing int: 0 destructing int: 0 @@ -158,15 +158,15 @@ constructing int begin construct A -construct a->x +construct a.x constructing int: 999 -assign a->y -assigning int: 0 0 -end construct A -copy constructing int: 0 -copy constructing int: 0 -begin copy construct A -copy construct this->x -copy constructing int: 999 -assign this->y +assign a.y +assigning int: 0 0 +end construct A +copy constructing int: 0 +copy constructing int: 0 +begin copy construct A +copy construct this.x +copy constructing int: 999 +assign this.y copy constructing int: 0 destructing int: 0 @@ -187,7 +187,7 @@ copy constructing int: 0 begin copy construct A -copy construct this->x -copy constructing int: 999 -assign this->y +copy construct this.x +copy constructing int: 999 +assign this.y copy constructing int: 0 destructing int: 0 Index: src/tests/alloc.c =================================================================== --- src/tests/alloc.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/alloc.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -1,3 +1,3 @@ -// +// // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo // @@ -5,6 +5,6 @@ // file "LICENCE" distributed with Cforall. // -// alloc.c -- -// +// alloc.c -- +// // Author : Peter A. Buhr // Created On : Wed Feb 3 07:56:22 2016 @@ -12,5 +12,5 @@ // Last Modified On : Thu Jul 20 16:01:10 2017 // Update Count : 318 -// +// #include @@ -19,5 +19,5 @@ #include // posix_memalign #include -#include // access C malloc, realloc +#include // access C malloc, realloc int * foo( int * p, int c ) { return p; } @@ -26,26 +26,26 @@ int main( void ) { - size_t dim = 10; - int * p; + size_t dim = 10; + int * p; char fill = '\1'; // allocation, non-array types - p = (void *)malloc( sizeof(*p) ); // C malloc, type unsafe + p = (void *)malloc( sizeof(*p) ); // C malloc, type unsafe *p = 0xdeadbeef; printf( "C malloc %#x\n", *p ); - free( p ); - - p = malloc(); // CFA malloc, type safe + free( p ); + + p = malloc(); // CFA malloc, type safe *p = 0xdeadbeef; printf( "CFA malloc %#x\n", *p ); - free( p ); - - p = alloc(); // CFA alloc, type safe + free( p ); + + p = alloc(); // CFA alloc, type safe *p = 0xdeadbeef; printf( "CFA alloc %#x\n", *p ); - free( p ); - - p = alloc( fill ); // CFA alloc, fill + free( p ); + + p = alloc( fill ); // CFA alloc, fill printf( "CFA alloc, fill %08x\n", *p ); @@ -54,24 +54,24 @@ printf( "\n" ); - p = calloc( dim, sizeof( *p ) ); // C array calloc, type unsafe + p = calloc( dim, sizeof( *p ) ); // C array calloc, type unsafe printf( "C array calloc, fill 0\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); - free( p ); - - p = calloc( dim ); // CFA array calloc, type safe + free( p ); + + p = calloc( dim ); // CFA array calloc, type safe printf( "CFA array calloc, fill 0\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); - free( p ); - - p = alloc( dim ); // CFA array alloc, type safe + free( p ); + + p = alloc( dim ); // CFA array alloc, type safe for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } printf( "CFA array alloc, no fill\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); - free( p ); - - p = alloc( 2 * dim, fill ); // CFA array alloc, fill + free( p ); + + p = alloc( 2 * dim, fill ); // CFA array alloc, fill printf( "CFA array alloc, fill %#x\n", fill ); for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } @@ -83,5 +83,5 @@ printf( "\n" ); - p = (void *)realloc( p, dim * sizeof(*p) ); // C realloc + p = (void *)realloc( p, dim * sizeof(*p) ); // C realloc for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } printf( "C realloc\n" ); @@ -89,5 +89,5 @@ printf( "\n" ); - p = realloc( p, 2 * dim * sizeof(*p) ); // CFA realloc + p = realloc( p, 2 * dim * sizeof(*p) ); // CFA realloc for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } printf( "CFA realloc\n" ); @@ -100,5 +100,5 @@ printf( "\n" ); - p = alloc( p, dim ); // CFA resize array alloc + p = alloc( p, dim ); // CFA resize array alloc for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } printf( "CFA resize alloc\n" ); @@ -106,5 +106,5 @@ printf( "\n" ); - p = alloc( p, 2 * dim ); // CFA resize array alloc + p = alloc( p, 2 * dim ); // CFA resize array alloc for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } printf( "CFA resize array alloc\n" ); @@ -112,5 +112,5 @@ printf( "\n" ); - p = alloc( p, dim ); // CFA array alloc + p = alloc( p, dim ); // CFA array alloc printf( "CFA resize array alloc\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } @@ -120,15 +120,15 @@ p = 0; - p = alloc( p, dim, fill ); // CFA array alloc, fill + p = alloc( p, dim, fill ); // CFA array alloc, fill printf( "CFA resize array alloc, fill\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); - p = alloc( p, 2 * dim, fill ); // CFA array alloc, fill + p = alloc( p, 2 * dim, fill ); // CFA array alloc, fill printf( "CFA resize array alloc, fill\n" ); for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); - p = alloc( p, dim, fill ); // CFA array alloc, fill + p = alloc( p, dim, fill ); // CFA array alloc, fill printf( "CFA resize array alloc, fill\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; } @@ -137,6 +137,6 @@ - struct Struct { int x; double y; }; - Struct st, st1, sta[dim], sta1[dim], * stp, * stp1; + struct Struct { int x; double y; }; + Struct st, st1, sta[dim], sta1[dim], * stp, * stp1; // alignment, non-array types @@ -144,40 +144,40 @@ enum { Alignment = 128 }; - stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign + stp = &(*(Struct*)memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign assert( (uintptr_t)stp % Alignment == 0 ); printf( "C memalign %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = (memalign( Alignment )){ 42, 42.5 }; // CFA memalign + free( stp ); + + stp = &(*memalign( Alignment )){ 42, 42.5 }; // CFA memalign assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA memalign %d %g\n", stp->x, stp->y ); - free( stp ); - - posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign + free( stp ); + + posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign *stp = (Struct){ 42, 42.5 }; assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA posix_memalign %d %g\n", stp->x, stp->y ); - free( stp ); - - posix_memalign( &stp, Alignment ); // CFA posix_memalign + free( stp ); + + posix_memalign( &stp, Alignment ); // CFA posix_memalign *stp = (Struct){ 42, 42.5 }; assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA posix_memalign %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = (aligned_alloc( Alignment )){ 42, 42.5 }; // CFA aligned_alloc + free( stp ); + + stp = &(*aligned_alloc( Alignment )){ 42, 42.5 }; // CFA aligned_alloc assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = (align_alloc( Alignment )){ 42, 42.5 }; // CFA align_alloc + free( stp ); + + stp = &(*align_alloc( Alignment )){ 42, 42.5 }; // CFA align_alloc assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA align_alloc %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = align_alloc( Alignment, fill ); // CFA memalign, fill + free( stp ); + + stp = align_alloc( Alignment, fill ); // CFA memalign, fill assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y ); - free( stp ); + free( stp ); @@ -185,5 +185,5 @@ printf( "\n" ); - stp = align_alloc( Alignment, dim ); // CFA array memalign + stp = align_alloc( Alignment, dim ); // CFA array memalign assert( (uintptr_t)stp % Alignment == 0 ); for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; } @@ -191,12 +191,12 @@ for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); } printf( "\n" ); - free( stp ); - - stp = align_alloc( Alignment, dim, fill ); // CFA array memalign, fill + free( stp ); + + stp = align_alloc( Alignment, dim, fill ); // CFA array memalign, fill assert( (uintptr_t)stp % Alignment == 0 ); printf( "CFA array align_alloc, fill\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); } printf( "\n" ); - free( stp ); + free( stp ); @@ -204,7 +204,7 @@ printf( "\n" ); - memset( &st, fill ); // CFA memset, type safe + memset( &st, fill ); // CFA memset, type safe printf( "CFA memset %#x %a\n", st.x, st.y ); - memcpy( &st1, &st ); // CFA memcpy, type safe + memcpy( &st1, &st ); // CFA memcpy, type safe printf( "CFA memcpy %#x %a\n", st1.x, st1.y ); @@ -213,10 +213,10 @@ printf( "\n" ); - memset( sta, dim, fill ); // CFA array memset, type safe + memset( sta, dim, fill ); // CFA array memset, type safe printf( "CFA array memset\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); } printf( "\n" ); - memcpy( sta1, sta, dim ); // CFA array memcpy, type safe + memcpy( sta1, sta, dim ); // CFA array memcpy, type safe printf( "CFA memcpy\n" ); for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); } @@ -245,18 +245,18 @@ printf( "\n" ); - float * fp = malloc() + 1; - printf( "pointer arithmetic %d\n", fp == fp - 1 ); - free( fp - 1 ); - - p = foo( bar( baz( malloc(), 0 ), 0 ), 0 ); + float * fp = malloc() + 1; + printf( "pointer arithmetic %d\n", fp == fp - 1 ); + free( fp - 1 ); + + p = foo( bar( baz( malloc(), 0 ), 0 ), 0 ); *p = 0xdeadbeef; printf( "CFA deep malloc %#x\n", *p ); - free( p ); + free( p ); stp = malloc(); printf( "\nSHOULD FAIL\n" ); - p = alloc( stp, dim * sizeof(*stp) ); - p = memset( stp, 10 ); - p = memcpy( &st1, &st ); + p = alloc( stp, dim * sizeof(*stp) ); + p = memset( stp, 10 ); + p = memcpy( &st1, &st ); } // main Index: src/tests/avltree/avl.h =================================================================== --- src/tests/avltree/avl.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/avltree/avl.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -21,7 +21,4 @@ // xxx - unbound type variable problems when trying to use new instead of create // forall( otype T, ttype Params | { void ?{}(T *, Params); } ) T * new( Params p ); - -forall(dtype T | { void ^?{}(T *); }) -void delete(T * x); // To-do: properly use height or balance factor @@ -58,8 +55,8 @@ forall(otype K | Comparable(K), otype V) -void ?{}(tree(K, V) *t, K key, V value); +void ?{}(tree(K, V) &t, K key, V value); forall(otype K, otype V) -void ^?{}(tree(K, V) * t); +void ^?{}(tree(K, V) & t); forall(otype K | Comparable(K), otype V) Index: src/tests/avltree/avl1.c =================================================================== --- src/tests/avltree/avl1.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/avltree/avl1.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -1,21 +1,22 @@ #include "avl.h" // #include "cwrap.h" +#include forall(otype K | Comparable(K), otype V) -void ?{}(tree(K, V) *t, K key, V value){ - (&t->key) { key }; - (&t->value) { value }; - t->parent = NULL; - t->left = NULL; - t->right = NULL; - t->balance = 0; +void ?{}(tree(K, V) &t, K key, V value){ + (t.key) { key }; + (t.value) { value }; + t.parent = NULL; + t.left = NULL; + t.right = NULL; + t.balance = 0; } forall(otype K, otype V) -void ^?{}(tree(K, V) * t){ - delete(t->left); - delete(t->right); - ^(&t->key){}; - ^(&t->value){}; +void ^?{}(tree(K, V) & t){ + delete(t.left); + delete(t.right); + ^(t.key){}; + ^(t.value){}; } @@ -24,5 +25,5 @@ // infinite loop trying to resolve ... t = malloc(); tree(K, V) * t = malloc(sizeof(tree(K,V))); - t { key, value }; + (*t){ key, value }; return t; } Index: src/tests/avltree/avl3.c =================================================================== --- src/tests/avltree/avl3.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/avltree/avl3.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -1,4 +1,5 @@ #include "avl.h" #include "avl-private.h" +#include // from stdlib @@ -32,5 +33,5 @@ t->left = NULL; t->right = NULL; - deleteSingleNode(t); + delete(t); } Index: src/tests/avltree/avl_test.c =================================================================== --- src/tests/avltree/avl_test.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/avltree/avl_test.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -1,4 +1,5 @@ #include "avl.h" #include "avl-private.h" +#include extern "C" { Index: src/tests/coroutine.c =================================================================== --- src/tests/coroutine.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/coroutine.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -1,10 +1,10 @@ -// +// // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo // // The contents of this file are covered under the licence agreement in the // file "LICENCE" distributed with Cforall. -// -// fibonacci.c -- -// +// +// fibonacci.c -- +// // Author : Thierry Delisle // Created On : Thu Jun 8 07:29:37 2017 @@ -12,5 +12,5 @@ // Last Modified On : Thu Jun 8 07:37:12 2017 // Update Count : 5 -// +// #include @@ -21,30 +21,30 @@ }; -void ?{}( Fibonacci * this ) { - this->fn = 0; +void ?{}( Fibonacci & this ) { + this.fn = 0; } -void main( Fibonacci * this ) { +void main( Fibonacci & this ) { int fn1, fn2; // retained between resumes - this->fn = 0; // case 0 - fn1 = this->fn; + this.fn = 0; // case 0 + fn1 = this.fn; suspend(); // return to last resume - this->fn = 1; // case 1 + this.fn = 1; // case 1 fn2 = fn1; - fn1 = this->fn; + fn1 = this.fn; suspend(); // return to last resume for ( ;; ) { // general case - this->fn = fn1 + fn2; + this.fn = fn1 + fn2; fn2 = fn1; - fn1 = this->fn; + fn1 = this.fn; suspend(); // return to last resume } // for } -int next( Fibonacci * this ) { +int next( Fibonacci & this ) { resume( this ); // transfer to last suspend - return this->fn; + return this.fn; } @@ -52,5 +52,5 @@ Fibonacci f1, f2; for ( int i = 1; i <= 10; i += 1 ) { - sout | next( &f1 ) | ' ' | next( &f2 ) | endl; + sout | next( f1 ) | ' ' | next( f2 ) | endl; } // for } Index: src/tests/dtor-early-exit.c =================================================================== --- src/tests/dtor-early-exit.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/dtor-early-exit.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -27,11 +27,11 @@ // don't want these called -void ?{}(A * a) { assert( false ); } -void ?{}(A * a, const char * name) { a->name = name; sout | "construct " | name | endl; a->x = (int*)malloc(); } -void ?{}(A * a, const char * name, int * ptr) { assert( false ); } - -A ?=?(A * a, A a) { sout | "assign " | a->name | " " | a.name; return a; } -void ?{}(A * a, A a) { sout | "copy construct " | a.name | endl; a->x = (int*)malloc(); } -void ^?{}(A * a) { sout | "destruct " | a->name | endl; free(a->x); } +void ?{}(A & a) { assert( false ); } +void ?{}(A & a, const char * name) { a.name = name; sout | "construct " | name | endl; a.x = (int*)malloc(); } +void ?{}(A & a, const char * name, int * ptr) { assert( false ); } + +A ?=?(A & a, A b) { sout | "assign " | a.name | " " | b.name; return a; } +void ?{}(A & a, A b) { sout | "copy construct " | b.name | endl; a.x = (int*)malloc(); } +void ^?{}(A & a) { sout | "destruct " | a.name | endl; free(a.x); } // test returns Index: src/tests/globals.c =================================================================== --- src/tests/globals.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/globals.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -5,5 +5,5 @@ }; -void ?{}( value_t * this ) { this->value = 22; } +void ?{}( value_t & this ) { this.value = 22; } //Standard case @@ -12,5 +12,5 @@ }; -void ?{}( g_t * this ) { (&this->val){}; } +void ?{}( g_t & this ) { (this.val){}; } g_t g; @@ -25,5 +25,5 @@ //Inline case struct gi_t; -void ?{}( gi_t * this ); +void ?{}( gi_t & this ); struct gi_t { @@ -31,5 +31,5 @@ } gi; -void ?{}( gi_t * this ) { (&this->val){}; } +void ?{}( gi_t & this ) { (this.val){}; } //Inline autogen case @@ -43,5 +43,5 @@ }; -void ?{}( gs_t * this ) { (&this->val){}; } +void ?{}( gs_t & this ) { (this.val){}; } static gs_t gs; @@ -56,5 +56,5 @@ //Static inline case struct gsi_t; -void ?{}( gsi_t * this ); +void ?{}( gsi_t & this ); static struct gsi_t { @@ -62,5 +62,5 @@ } gsi; -void ?{}( gsi_t * this ) { (&this->val){}; } +void ?{}( gsi_t & this ) { (this.val){}; } //Static inline autogen case Index: src/tests/init_once.c =================================================================== --- src/tests/init_once.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/init_once.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -60,29 +60,29 @@ return -1; } -void ?{}(array * arr) { - memset(arr->elems, 0, sizeof(arr->elems)); - arr->length = 0; +void ?{}(array & arr) { + memset(arr.elems, 0, sizeof(arr.elems)); + arr.length = 0; } array constructed; array destructed; -void ?{}(init_once * x) { - assert( find( &constructed, x ) == -1 ); - remove( &destructed, x ); - insert( &constructed, x ); +void ?{}(init_once & x) { + assert( find( &constructed, &x ) == -1 ); + remove( &destructed, &x ); + insert( &constructed, &x ); - x->x = malloc(sizeof(int)); + x.x = malloc(sizeof(int)); } -void ?{}(init_once * x, init_once other) { +void ?{}(init_once & x, init_once other) { x{}; // reuse default ctor } -void ^?{}(init_once * x) { - assert( find( &destructed, x ) == -1 ); - remove( &constructed, x ); - insert( &destructed, x ); +void ^?{}(init_once & x) { + assert( find( &destructed, &x ) == -1 ); + remove( &constructed, &x ); + insert( &destructed, &x ); - free(x->x); + free(x.x); } //*** end setup @@ -125,5 +125,5 @@ init_once x; init_once y = x; - (&x) {}; // ensure this doesn't execute + x{}; // ensure this doesn't execute break; } Index: src/tests/memberCtors.c =================================================================== --- src/tests/memberCtors.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/memberCtors.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -3,26 +3,26 @@ }; -void ?{}(WrappedInt * this) { +void ?{}(WrappedInt & this) { printf("constructing int\n"); - this->x = 0; + this.x = 0; } -void ?{}(WrappedInt * this, WrappedInt other) { +void ?{}(WrappedInt & this, WrappedInt other) { printf("copy constructing int: %d\n", other.x); - this->x = other.x; + this.x = other.x; } -void ?{}(WrappedInt * this, int x) { +void ?{}(WrappedInt & this, int x) { printf("constructing int: %d\n", x); - this->x = x; + this.x = x; } -void ^?{}(WrappedInt * this) { - printf("destructing int: %d\n", this->x); +void ^?{}(WrappedInt & this) { + printf("destructing int: %d\n", this.x); } -void ?=?(WrappedInt * this, int x) { - printf("assigning int: %d %d\n", this->x, x); - this->x = x; +void ?=?(WrappedInt & this, int x) { + printf("assigning int: %d %d\n", this.x, x); + this.x = x; } @@ -31,33 +31,33 @@ }; -void ?{}(A * a) { +void ?{}(A & a) { // currently must define default ctor, since there's no "= default" syntax } -void ?{}(A * a, int x) { +void ?{}(A & a, int x) { printf("begin construct A\n"); - printf("construct a->x\n"); - (&a->x){ x+999 }; - printf("assign a->y\n"); - a->y = 0; // not a constructor - default constructor will be inserted + printf("construct a.x\n"); + (a.x){ x+999 }; + printf("assign a.y\n"); + a.y = 0; // not a constructor - default constructor will be inserted printf("end construct A\n"); } // z never constructed - will be automatically default constructed -void ?{}(A * this, A other) { +void ?{}(A & this, A other) { printf("begin copy construct A\n"); - printf("copy construct this->x\n"); - (&this->x){ other.x }; - printf("assign this->y\n"); - this->y = other.y; // not a constructor - copy constructor will be inserted + printf("copy construct this.x\n"); + (this.x){ other.x }; + printf("assign this.y\n"); + this.y = other.y; // not a constructor - copy constructor will be inserted printf("end copy construct A\n"); } // z never constructed - will be automatically copy constructed -A ?=?(A * this, A other) { +A ?=?(A & this, A other) { printf("begin ?=? A\n"); - this->x = other.x; - this->y = other.y; - this->z = other.z; + this.x = other.x; + this.y = other.y; + this.z = other.z; printf("end ?=? A\n"); - return *this; + return this; } @@ -66,19 +66,19 @@ }; -void ?{}(B * b) { +void ?{}(B & b) { printf("begin construct B\n"); - printf("assign b->a2\n"); - b->a2 = (A) { 2 }; - printf("construct b->a1\n"); - (&b->a1){ 1 }; + printf("assign b.a2\n"); + b.a2 = (A) { 2 }; + printf("construct b.a1\n"); + (b.a1){ 1 }; #ifdef ERR1 - (&b->a2){ b->a3 }; // error, b->a2 was used previously but is explicitly constructed + (b.a2){ b.a3 }; // error, b->a2 was used previously but is explicitly constructed #endif printf("end construct B\n"); } // a2, a3 never constructed - will be automatically default constructed -void ^?{}(B * b) { - b->a2 = (A) { 0 }; - ^(&b->a1){}; +void ^?{}(B & b) { + b.a2 = (A) { 0 }; + ^(b.a1){}; } // a2, a3 never destructed - will be automatically destructed Index: src/tests/monitor.c =================================================================== --- src/tests/monitor.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/monitor.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -8,19 +8,19 @@ }; -void ?{}(global_t * this) { - this->value = 0; +void ?{}(global_t & this) { + this.value = 0; } static global_t global; -void increment3( global_t * mutex this ) { - this->value += 1; +void increment3( global_t & mutex this ) { + this.value += 1; } -void increment2( global_t * mutex this ) { +void increment2( global_t & mutex this ) { increment3( this ); } -void increment( global_t * mutex this ) { +void increment( global_t & mutex this ) { increment2( this ); } @@ -28,7 +28,7 @@ thread MyThread {}; -void main( MyThread* this ) { +void main( MyThread & this ) { for(int i = 0; i < 1_000_000; i++) { - increment( &global ); + increment( global ); } } Index: src/tests/multi-monitor.c =================================================================== --- src/tests/multi-monitor.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/multi-monitor.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -10,29 +10,32 @@ static monitor_t m1, m2, m3; -void increment( monitor_t * mutex p1, monitor_t * mutex p2, int * value ) { - *value += 1; +void increment( monitor_t & mutex p1, monitor_t & mutex p2, int & value ) { + value += 1; } -struct MyThread { - thread_desc __thrd; +thread MyThread { int target; }; -DECL_THREAD(MyThread); - -void ?{}( MyThread * this, int target ) { - this->target = target; +void ?{}( MyThread & this, int target ) { + this.target = target; } -void ^?{}( MyThread * mutex this ) {} +void ^?{}( MyThread & mutex this ) {} -void main( MyThread* this ) { +void main( MyThread & this ) { for(int i = 0; i < 1000000; i++) { - choose(this->target) { - case 0: increment( &m1, &m2, &global12 ); - case 1: increment( &m2, &m3, &global23 ); - case 2: increment( &m1, &m3, &global13 ); + choose(this.target) { + case 0: increment( m1, m2, global12 ); + case 1: increment( m2, m3, global23 ); + case 2: increment( m1, m3, global13 ); } } +} + +forall(dtype T | sized(T) | { void ^?{}(T & mutex); }) +void delete_mutex(T * x) { + ^(*x){}; + free(x); } @@ -40,11 +43,11 @@ processor p; { - scoped(MyThread) * f[6]; + MyThread * f[6]; for(int i = 0; i < 6; i++) { - f[i] = ((scoped(MyThread) *)malloc()){ i % 3 }; + f[i] = new(i % 3); } for(int i = 0; i < 6; i++) { - delete( f[i] ); + delete_mutex( f[i] ); } } Index: src/tests/multiDimension.c =================================================================== --- src/tests/multiDimension.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/multiDimension.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -4,30 +4,30 @@ }; -void ?{}(X * this) { +void ?{}(X & this) { printf("default constructing\n"); - (&this->a){ 123 }; - this->ptr = malloc(sizeof(int)); + (this.a){ 123 }; + this.ptr = malloc(sizeof(int)); } -void ?{}(X * this, X other) { +void ?{}(X & this, X other) { printf("copy constructing\n"); - (&this->a){ other.a }; - this->ptr = malloc(sizeof(int)); + (this.a){ other.a }; + this.ptr = malloc(sizeof(int)); } -void ?{}(X * this, int a) { +void ?{}(X & this, int a) { printf("constructing with %d\n", a); - (&this->a){ a }; - this->ptr = malloc(sizeof(int)); + (this.a){ a }; + this.ptr = malloc(sizeof(int)); } -void ^?{}(X * this) { +void ^?{}(X & this) { printf("destructing\n"); - free(this->ptr); + free(this.ptr); } -X ?=?(X * this, X other) { - this->a = other.a; - return *this; +X ?=?(X & this, X other) { + this.a = other.a; + return this; } Index: src/tests/operators.c =================================================================== --- src/tests/operators.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/operators.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -11,5 +11,5 @@ } -int ?=?( int *a, int b ) { +int ?=?( int &a, int b ) { return 0; } Index: src/tests/preempt.c =================================================================== --- src/tests/preempt.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/preempt.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -16,11 +16,11 @@ }; -void ?{}( worker_t * this, int value ) { - this->value = value; +void ?{}( worker_t & this, int value ) { + this.value = value; } -void main(worker_t * this) { +void main(worker_t & this) { while(counter < 1000) { - if( (counter % 7) == this->value ) { + if( (counter % 7) == this.value ) { int next = __atomic_add_fetch_4(&counter, 1, __ATOMIC_SEQ_CST); if( (next % 100) == 0 ) printf("%d\n", next); Index: src/tests/rational.c =================================================================== --- src/tests/rational.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/rational.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -1,10 +1,10 @@ -// +// // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo // // The contents of this file are covered under the licence agreement in the // file "LICENCE" distributed with Cforall. -// +// // rational.c -- test rational number package -// +// // Author : Peter A. Buhr // Created On : Mon Mar 28 08:43:12 2016 @@ -12,5 +12,5 @@ // Last Modified On : Wed May 17 15:46:35 2017 // Update Count : 65 -// +// #include @@ -20,7 +20,7 @@ // UNNECESSARY, FIX ME -void ?{}( int * this ) { *this = 0; } -void ?{}( int * this, zero_t ) { *this = 0; } -void ?{}( int * this, one_t ) { *this = 1; } +void ?{}( int & this ) { this = 0; } +void ?{}( int & this, zero_t ) { this = 0; } +void ?{}( int & this, one_t ) { this = 1; } double convert( int i ) { return (double)i; } int convert( double d ) { return (int)d; } Index: src/tests/sched-int-barge.c =================================================================== --- src/tests/sched-int-barge.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/sched-int-barge.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -28,15 +28,15 @@ }; -void ?{} ( global_data_t * this ) { - this->done = false; - this->counter = 0; - this->state = BARGE; +void ?{} ( global_data_t & this ) { + this.done = false; + this.counter = 0; + this.state = BARGE; - this->do_signal = 6; - this->do_wait1 = 1; - this->do_wait2 = 3; + this.do_signal = 6; + this.do_wait1 = 1; + this.do_wait2 = 3; } -void ^?{} ( global_data_t * this ) {} +void ^?{} ( global_data_t & this ) {} global_t globalA; @@ -48,30 +48,30 @@ thread Threads {}; -bool logicC( global_t * mutex a, global_t * mutex b, global_data_t * mutex c ) { - c->counter++; +bool logicC( global_t & mutex a, global_t & mutex b, global_data_t & mutex c ) { + c.counter++; - if( (c->counter % 1000) == 0 ) sout | c->counter | endl; + if( (c.counter % 1000) == 0 ) sout | c.counter | endl; - int action = c->counter % 10; + int action = c.counter % 10; if( action == 0 ) { - c->do_signal = max( ((unsigned)rand48()) % 10, 1); - c->do_wait1 = ((unsigned)rand48()) % (c->do_signal); - c->do_wait2 = ((unsigned)rand48()) % (c->do_signal); + c.do_signal = max( ((unsigned)rand48()) % 10, 1); + c.do_wait1 = ((unsigned)rand48()) % (c.do_signal); + c.do_wait2 = ((unsigned)rand48()) % (c.do_signal); - if(c->do_wait1 == c->do_wait2) sout | "Same" | endl; + if(c.do_wait1 == c.do_wait2) sout | "Same" | endl; } - if( action == c->do_wait1 || action == c->do_wait2 ) { - c->state = WAIT; + if( action == c.do_wait1 || action == c.do_wait2 ) { + c.state = WAIT; wait( &cond ); - if(c->state != SIGNAL) { - sout | "ERROR Barging detected" | c->counter | endl; + if(c.state != SIGNAL) { + sout | "ERROR Barging detected" | c.counter | endl; abort(); } } - else if( action == c->do_signal ) { - c->state = SIGNAL; + else if( action == c.do_signal ) { + c.state = SIGNAL; signal( &cond ); @@ -79,21 +79,21 @@ } else { - c->state = BARGE; + c.state = BARGE; } - if( c->counter >= N ) c->done = true; - return !c->done; + if( c.counter >= N ) c.done = true; + return !c.done; } -bool logicB( global_t * mutex a, global_t * mutex b ) { - return logicC(a, b, &globalC); +bool logicB( global_t & mutex a, global_t & mutex b ) { + return logicC(a, b, globalC); } -bool logicA( global_t * mutex a ) { - return logicB(a, &globalB); +bool logicA( global_t & mutex a ) { + return logicB(a, globalB); } -void main( Threads* this ) { - while( logicA(&globalA) ) { yield(); }; +void main( Threads & this ) { + while( logicA(globalA) ) { yield(); }; } @@ -101,9 +101,9 @@ int main(int argc, char* argv[]) { - rand48seed(0); - processor p; - { - Threads t[17]; - the_threads = (thread_desc*)t; - } + rand48seed(0); + processor p; + { + Threads t[17]; + the_threads = (thread_desc*)t; + } } Index: src/tests/sched-int-block.c =================================================================== --- src/tests/sched-int-block.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/sched-int-block.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -24,10 +24,10 @@ }; -void ?{} ( global_data_t * this ) { - this->last_thread = NULL; - this->last_signaller = NULL; +void ?{} ( global_data_t & this ) { + this.last_thread = NULL; + this.last_signaller = NULL; } -void ^?{} ( global_data_t * this ) {} +void ^?{} ( global_data_t & this ) {} global_data_t globalA, globalB; @@ -38,15 +38,15 @@ //------------------------------------------------------------------------------ -void wait_op( global_data_t * mutex a, global_data_t * mutex b, unsigned i ) { +void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned i ) { wait( &cond, (uintptr_t)this_thread ); yield( ((unsigned)rand48()) % 10 ); - if(a->last_thread != a->last_signaller || b->last_thread != b->last_signaller ) { - sout | "ERROR Barging detected, expected" | a->last_signaller | b->last_signaller | "got" | a->last_thread | b->last_thread | endl; + if(a.last_thread != a.last_signaller || b.last_thread != b.last_signaller ) { + sout | "ERROR Barging detected, expected" | a.last_signaller | b.last_signaller | "got" | a.last_thread | b.last_thread | endl; abort(); } - a->last_thread = b->last_thread = this_thread; + a.last_thread = b.last_thread = this_thread; yield( ((unsigned)rand48()) % 10 ); @@ -54,15 +54,15 @@ thread Waiter {}; -void main( Waiter* this ) { +void main( Waiter & this ) { for( int i = 0; i < N; i++ ) { - wait_op( &globalA, &globalB, i ); + wait_op( globalA, globalB, i ); } } //------------------------------------------------------------------------------ -void signal_op( global_data_t * mutex a, global_data_t * mutex b ) { +void signal_op( global_data_t & mutex a, global_data_t & mutex b ) { yield( ((unsigned)rand48()) % 10 ); - a->last_thread = b->last_thread = a->last_signaller = b->last_signaller = this_thread; + [a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = this_thread; if( !is_empty( &cond ) ) { @@ -77,6 +77,6 @@ yield( ((unsigned)rand48()) % 10 ); - if(a->last_thread != next || b->last_thread != next) { - sout | "ERROR Barging detected, expected" | next | "got" | a->last_thread | b->last_thread | endl; + if(a.last_thread != next || b.last_thread != next) { + sout | "ERROR Barging detected, expected" | next | "got" | a.last_thread | b.last_thread | endl; abort(); } @@ -86,21 +86,22 @@ thread Signaller {}; -void main( Signaller* this ) { +void main( Signaller & this ) { while( !done ) { - signal_op( &globalA, &globalB ); + signal_op( globalA, globalB ); } } //------------------------------------------------------------------------------ -void barge_op( global_data_t * mutex a ) { - a->last_thread = this_thread; +void barge_op( global_data_t & mutex a ) { + a.last_thread = this_thread; } thread Barger {}; -void main( Barger* this ) { +void main( Barger & this ) { for( unsigned i = 0; !done; i++ ) { //Choose some monitor to barge into with some irregular pattern bool choose_a = (i % 13) > (i % 17); - barge_op( choose_a ? &globalA : &globalB ); + if ( choose_a ) barge_op( globalA ); + else barge_op( globalB ); } } Index: src/tests/sched-int-disjoint.c =================================================================== --- src/tests/sched-int-disjoint.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/sched-int-disjoint.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -20,6 +20,6 @@ monitor global_data_t; -void ?{}( global_data_t * this ); -void ^?{} ( global_data_t * this ); +void ?{}( global_data_t & this ); +void ^?{} ( global_data_t & this ); monitor global_data_t { @@ -32,22 +32,22 @@ volatile bool all_done; -void ?{}( global_data_t * this ) { - this->counter == 0; - this->state = BARGE; +void ?{}( global_data_t & this ) { + this.counter == 0; + this.state = BARGE; } -void ^?{} ( global_data_t * this ) {} +void ^?{} ( global_data_t & this ) {} //------------------------------------------------------------------------------ // Barging logic -void barge( global_data_t * mutex d ) { - d->state = BARGE; +void barge( global_data_t & mutex d ) { + d.state = BARGE; } thread Barger {}; -void main( Barger * this ) { +void main( Barger & this ) { while( !all_done ) { - barge( &data ); + barge( data ); yield(); } @@ -56,21 +56,21 @@ //------------------------------------------------------------------------------ // Waiting logic -bool wait( global_t * mutex m, global_data_t * mutex d ) { +bool wait( global_t & mutex m, global_data_t & mutex d ) { wait( &cond ); - if( d->state != SIGNAL ) { + if( d.state != SIGNAL ) { sout | "ERROR barging!" | endl; } - d->counter++; + d.counter++; - if( (d->counter % 1000) == 0 ) sout | d->counter | endl; + if( (d.counter % 1000) == 0 ) sout | d.counter | endl; - return d->counter < N; + return d.counter < N; } thread Waiter {}; -void main( Waiter * this ) { - while( wait( &mut, &data ) ) { yield(); } +void main( Waiter & this ) { + while( wait( mut, data ) ) { yield(); } } @@ -78,11 +78,11 @@ //------------------------------------------------------------------------------ // Signalling logic -void signal( condition * cond, global_t * mutex a, global_data_t * mutex b ) { - b->state = SIGNAL; +void signal( condition * cond, global_t & mutex a, global_data_t & mutex b ) { + b.state = SIGNAL; signal( cond ); } -void logic( global_t * mutex a ) { - signal( &cond, a, &data ); +void logic( global_t & mutex a ) { + signal( &cond, a, data ); yield( (unsigned)rand48() % 10 ); @@ -97,7 +97,7 @@ thread Signaller {}; -void main( Signaller * this ) { +void main( Signaller & this ) { while( !all_done ) { - logic( &mut ); + logic( mut ); yield(); } Index: src/tests/sched-int-wait.c =================================================================== --- src/tests/sched-int-wait.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/sched-int-wait.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -33,17 +33,17 @@ //---------------------------------------------------------------------------------------------------- // Tools -void signal( condition * cond, global_t * mutex a, global_t * mutex b ) { +void signal( condition * cond, global_t & mutex a, global_t & mutex b ) { signal( cond ); } -void signal( condition * cond, global_t * mutex a, global_t * mutex b, global_t * mutex c ) { +void signal( condition * cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) { signal( cond ); } -void wait( condition * cond, global_t * mutex a, global_t * mutex b ) { +void wait( condition * cond, global_t & mutex a, global_t & mutex b ) { wait( cond ); } -void wait( condition * cond, global_t * mutex a, global_t * mutex b, global_t * mutex c ) { +void wait( condition * cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) { wait( cond ); } @@ -51,5 +51,5 @@ //---------------------------------------------------------------------------------------------------- // Signaler -void main( Signaler* this ) { +void main( Signaler & this ) { while( waiter_left != 0 ) { @@ -57,14 +57,14 @@ switch( action ) { case 0: - signal( &condABC, &globalA, &globalB, &globalC ); + signal( &condABC, globalA, globalB, globalC ); break; case 1: - signal( &condAB , &globalA, &globalB ); + signal( &condAB , globalA, globalB ); break; case 2: - signal( &condBC , &globalB, &globalC ); + signal( &condBC , globalB, globalC ); break; case 3: - signal( &condAC , &globalA, &globalC ); + signal( &condAC , globalA, globalC ); break; default: @@ -78,7 +78,7 @@ //---------------------------------------------------------------------------------------------------- // Waiter ABC -void main( WaiterABC* this ) { +void main( WaiterABC & this ) { for( int i = 0; i < N; i++ ) { - wait( &condABC, &globalA, &globalB, &globalC ); + wait( &condABC, globalA, globalB, globalC ); } @@ -88,7 +88,7 @@ //---------------------------------------------------------------------------------------------------- // Waiter AB -void main( WaiterAB* this ) { +void main( WaiterAB & this ) { for( int i = 0; i < N; i++ ) { - wait( &condAB , &globalA, &globalB ); + wait( &condAB , globalA, globalB ); } @@ -98,7 +98,7 @@ //---------------------------------------------------------------------------------------------------- // Waiter AC -void main( WaiterAC* this ) { +void main( WaiterAC & this ) { for( int i = 0; i < N; i++ ) { - wait( &condAC , &globalA, &globalC ); + wait( &condAC , globalA, globalC ); } @@ -108,7 +108,7 @@ //---------------------------------------------------------------------------------------------------- // Waiter BC -void main( WaiterBC* this ) { +void main( WaiterBC & this ) { for( int i = 0; i < N; i++ ) { - wait( &condBC , &globalB, &globalC ); + wait( &condBC , globalB, globalC ); } Index: src/tests/test.py =================================================================== --- src/tests/test.py (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/test.py (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -31,5 +31,5 @@ # parses the Makefile to find the machine type (32-bit / 64-bit) def getMachineType(): - sh('echo "void ?{}(int*a,int b){}int main(){return 0;}" > .dummy.c') + sh('echo "void ?{}(int&a,int b){}int main(){return 0;}" > .dummy.c') ret, out = sh("make .dummy -s", print2stdout=True) Index: src/tests/thread.c =================================================================== --- src/tests/thread.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/thread.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -7,17 +7,17 @@ thread Second { semaphore* lock; }; -void ?{}( First * this, semaphore* lock ) { this->lock = lock; } -void ?{}( Second * this, semaphore* lock ) { this->lock = lock; } +void ?{}( First & this, semaphore & lock ) { this.lock = &lock; } +void ?{}( Second & this, semaphore & lock ) { this.lock = &lock; } -void main(First* this) { +void main(First& this) { for(int i = 0; i < 10; i++) { sout | "First : Suspend No." | i + 1 | endl; yield(); } - V(this->lock); + V(this.lock); } -void main(Second* this) { - P(this->lock); +void main(Second& this) { + P(this.lock); for(int i = 0; i < 10; i++) { sout | "Second : Suspend No." | i + 1 | endl; @@ -33,6 +33,6 @@ processor p; { - First f = { &lock }; - Second s = { &lock }; + First f = { lock }; + Second s = { lock }; } } Index: src/tests/tupleAssign.c =================================================================== --- src/tests/tupleAssign.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/tupleAssign.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -48,5 +48,5 @@ int z; } x; - X ?=?(X * x, double d) {} + X ?=?(X & x, double d) {} [int, double, int] t; Index: src/tests/tupleMember.c =================================================================== --- src/tests/tupleMember.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/tupleMember.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -34,5 +34,5 @@ } v; -lvalue V h() { +V & h() { static V local = { 111, { 222, 333 }, 444.5 }; return local; Index: src/tests/tupleVariadic.c =================================================================== --- src/tests/tupleVariadic.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/tupleVariadic.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -29,5 +29,5 @@ } -forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) +forall( dtype T, ttype Params | sized(T) | { void ?{}(T &, Params); } ) T * new(Params p); @@ -38,44 +38,44 @@ // xxx - eventually this will be collapsed...x -void ?{}(array * a) { - a->size = 0; - a->data = 0; +void ?{}(array & a) { + a.size = 0; + a.data = 0; printf("called ?{} with no a\n"); } -void ?{}(array * a, int a0) { - a->size = 1; - a->data = (int*)malloc(sizeof(int)*a->size); - a->data[0] = a0; +void ?{}(array & a, int a0) { + a.size = 1; + a.data = (int*)malloc(sizeof(int)*a.size); + a.data[0] = a0; printf("called ?{} with a: %d\n", a0); } -void ?{}(array * a, int a0, int a1) { - a->size = 2; - a->data = (int*)malloc(sizeof(int)*a->size); - a->data[0] = a0; - a->data[1] = a1; +void ?{}(array & a, int a0, int a1) { + a.size = 2; + a.data = (int*)malloc(sizeof(int)*a.size); + a.data[0] = a0; + a.data[1] = a1; printf("called ?{} with a: %d %d\n", a0, a1); } -void ?{}(array * a, int a0, int a1, int a2) { - a->size = 3; - a->data = (int*)malloc(sizeof(int)*a->size); - a->data[0] = a0; - a->data[1] = a1; - a->data[2] = a2; +void ?{}(array & a, int a0, int a1, int a2) { + a.size = 3; + a.data = (int*)malloc(sizeof(int)*a.size); + a.data[0] = a0; + a.data[1] = a1; + a.data[2] = a2; printf("called ?{} with a: %d %d %d\n", a0, a1, a2); } // test use of a tuple argument -[void] ?{}(array * a, [int, int, int, int] args) { +[void] ?{}(array & a, [int, int, int, int] args) { int a0, a1, a2, a3; [a0, a1, a2, a3] = args; - a->size = 4; - a->data = malloc(sizeof(int)*a->size); - a->data[0] = a0; - a->data[1] = a1; - a->data[2] = a2; - a->data[3] = a3; + a.size = 4; + a.data = malloc(sizeof(int)*a.size); + a.data[0] = a0; + a.data[1] = a1; + a.data[2] = a2; + a.data[3] = a3; printf("called ?{} with a: %d %d %d %d\n", a0, a1, a2, a3); } Index: src/tests/vector/array.h =================================================================== --- src/tests/vector/array.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/vector/array.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -21,5 +21,5 @@ // element has index 0. trait array( otype array_type, otype elt_type ) { - lvalue elt_type ?[?]( array_type, int ); + elt_type & ?[?]( array_type, int ); }; Index: src/tests/vector/vector_int.c =================================================================== --- src/tests/vector/vector_int.c (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/vector/vector_int.c (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -20,25 +20,25 @@ #define DEFAULT_CAPACITY 20 -void ?{}( vector_int * vec ) { +void ?{}( vector_int & vec ) { vec { DEFAULT_CAPACITY }; } -void ?{}( vector_int * vec, int reserve ) { - vec->last = -1; - vec->capacity = reserve; - vec->data = malloc( sizeof( int ) * reserve ); +void ?{}( vector_int & vec, int reserve ) { + vec.last = -1; + vec.capacity = reserve; + vec.data = malloc( sizeof( int ) * reserve ); } -void ?{}( vector_int * vec, vector_int other ) { - vec->last = other.last; - vec->capacity = other.capacity; - vec->data = malloc( sizeof( int ) * other.capacity ); - for (int i = 0; i < vec->last; i++) { - vec->data[i] = other.data[i]; +void ?{}( vector_int & vec, vector_int other ) { + vec.last = other.last; + vec.capacity = other.capacity; + vec.data = malloc( sizeof( int ) * other.capacity ); + for (int i = 0; i < vec.last; i++) { + vec.data[i] = other.data[i]; } } -void ^?{}( vector_int * vec ) { - free( vec->data ); +void ^?{}( vector_int & vec ) { + free( vec.data ); } @@ -61,5 +61,5 @@ // implement bounded_array -lvalue int ?[?]( vector_int * vec, int index ) { +int & ?[?]( vector_int * vec, int index ) { return vec->data[ index ]; } Index: src/tests/vector/vector_int.h =================================================================== --- src/tests/vector/vector_int.h (revision 9f072329e8f316763ee3fcb5b02e8bdd98c4f4ed) +++ src/tests/vector/vector_int.h (revision d3e4d6c5594ad824607e752edfdf46ce81abdc7f) @@ -24,8 +24,8 @@ } vector_int; -void ?{}( vector_int * ); // allocate vector with default capacity -void ?{}( vector_int *, int reserve ); // allocate vector with specified capacity -void ?{}( vector_int * vec, vector_int other ); // copy constructor -void ^?{}( vector_int * ); // deallocate vector's storage +void ?{}( vector_int & ); // allocate vector with default capacity +void ?{}( vector_int &, int reserve ); // allocate vector with specified capacity +void ?{}( vector_int & vec, vector_int other ); // copy constructor +void ^?{}( vector_int & ); // deallocate vector's storage void reserve( vector_int *vec, int reserve ); // reserve more capacity @@ -34,6 +34,6 @@ // implement bounded_array -lvalue int ?[?]( vector_int * vec, int index ); // access to arbitrary element (does not resize) -int last( vector_int * vec ); // return last element +int & ?[?]( vector_int * vec, int index ); // access to arbitrary element (does not resize) +int last( vector_int * vec ); // return last element // Local Variables: //