Index: src/CodeGen/GenType.cc =================================================================== --- src/CodeGen/GenType.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/CodeGen/GenType.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -26,24 +26,26 @@ namespace CodeGen { - class GenType : public Visitor { - public: + struct GenType : public WithVisitorRef, public WithShortCircuiting { GenType( const std::string &typeString, bool pretty = false, bool genC = false, bool lineMarks = false ); std::string get_typeString() const { return typeString; } void set_typeString( const std::string &newValue ) { typeString = newValue; } - virtual void visit( FunctionType *funcType ); - virtual void visit( VoidType *voidType ); - virtual void visit( BasicType *basicType ); - 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 ); - virtual void visit( EnumInstType *enumInst ); - virtual void visit( TypeInstType *typeInst ); - virtual void visit( TupleType * tupleType ); - virtual void visit( VarArgsType *varArgsType ); - virtual void visit( ZeroType *zeroType ); - virtual void visit( OneType *oneType ); + void previsit( BaseSyntaxNode * ); + void postvisit( BaseSyntaxNode * ); + + void postvisit( FunctionType * funcType ); + void postvisit( VoidType * voidType ); + void postvisit( BasicType * basicType ); + void postvisit( PointerType * pointerType ); + void postvisit( ArrayType * arrayType ); + void postvisit( ReferenceType * refType ); + void postvisit( StructInstType * structInst ); + void postvisit( UnionInstType * unionInst ); + void postvisit( EnumInstType * enumInst ); + void postvisit( TypeInstType * typeInst ); + void postvisit( TupleType * tupleType ); + void postvisit( VarArgsType * varArgsType ); + void postvisit( ZeroType * zeroType ); + void postvisit( OneType * oneType ); private: @@ -59,5 +61,5 @@ std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) { - GenType gt( baseString, pretty, genC, lineMarks ); + PassVisitor gt( baseString, pretty, genC, lineMarks ); std::ostringstream os; @@ -68,5 +70,5 @@ type->accept( gt ); - return os.str() + gt.get_typeString(); + return os.str() + gt.pass.get_typeString(); } @@ -77,11 +79,24 @@ GenType::GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks ) : typeString( typeString ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {} - void GenType::visit( VoidType *voidType ) { + // *** BaseSyntaxNode + void GenType::previsit( BaseSyntaxNode * ) { + // turn off automatic recursion for all nodes, to allow each visitor to + // precisely control the order in which its children are visited. + visit_children = false; + } + + void GenType::postvisit( BaseSyntaxNode * node ) { + std::stringstream ss; + node->print( ss ); + assertf( false, "Unhandled node reached in GenType: %s", ss.str().c_str() ); + } + + void GenType::postvisit( VoidType * voidType ) { typeString = "void " + typeString; handleQualifiers( voidType ); } - void GenType::visit( BasicType *basicType ) { - BasicType::Kind kind = basicType->get_kind(); + void GenType::postvisit( BasicType * basicType ) { + BasicType::Kind kind = basicType->kind; assert( 0 <= kind && kind < BasicType::NUMBER_OF_BASIC_TYPES ); typeString = std::string( BasicType::typeNames[kind] ) + " " + typeString; @@ -89,5 +104,5 @@ } - void GenType::genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic ) { + void GenType::genArray( const Type::Qualifiers & qualifiers, Type * base, Expression *dimension, bool isVarLen, bool isStatic ) { std::ostringstream os; if ( typeString != "" ) { @@ -126,11 +141,11 @@ typeString = os.str(); - base->accept( *this ); - } - - void GenType::visit( PointerType *pointerType ) { - assert( pointerType->get_base() != 0); - if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->get_dimension() ) { - genArray( pointerType->get_qualifiers(), pointerType->get_base(), pointerType->get_dimension(), pointerType->get_isVarLen(), pointerType->get_isStatic() ); + base->accept( *visitor ); + } + + void GenType::postvisit( PointerType * pointerType ) { + assert( pointerType->base != 0); + if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->dimension ) { + genArray( pointerType->get_qualifiers(), pointerType->base, pointerType->dimension, pointerType->get_isVarLen(), pointerType->get_isStatic() ); } else { handleQualifiers( pointerType ); @@ -140,21 +155,21 @@ typeString = "*" + typeString; } // if - pointerType->get_base()->accept( *this ); - } // if - } - - 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); + pointerType->base->accept( *visitor ); + } // if + } + + void GenType::postvisit( ArrayType * arrayType ) { + genArray( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->get_isVarLen(), arrayType->get_isStatic() ); + } + + void GenType::postvisit( ReferenceType * refType ) { + assert( refType->base != 0); assertf( ! genC, "Reference types should not reach code generation." ); handleQualifiers( refType ); typeString = "&" + typeString; - refType->get_base()->accept( *this ); - } - - void GenType::visit( FunctionType *funcType ) { + refType->base->accept( *visitor ); + } + + void GenType::postvisit( FunctionType * funcType ) { std::ostringstream os; @@ -169,5 +184,5 @@ /************* parameters ***************/ - const std::list &pars = funcType->get_parameters(); + const std::list &pars = funcType->parameters; if ( pars.empty() ) { @@ -191,17 +206,17 @@ typeString = os.str(); - if ( funcType->get_returnVals().size() == 0 ) { + if ( funcType->returnVals.size() == 0 ) { typeString = "void " + typeString; } else { - funcType->get_returnVals().front()->get_type()->accept( *this ); + funcType->returnVals.front()->get_type()->accept( *visitor ); } // if // add forall - if( ! funcType->get_forall().empty() && ! genC ) { + if( ! funcType->forall.empty() && ! genC ) { // assertf( ! genC, "Aggregate type parameters should not reach code generation." ); std::ostringstream os; PassVisitor cg( os, pretty, genC, lineMarks ); os << "forall("; - cg.pass.genCommaList( funcType->get_forall().begin(), funcType->get_forall().end() ); + cg.pass.genCommaList( funcType->forall.begin(), funcType->forall.end() ); os << ")" << std::endl; typeString = os.str() + typeString; @@ -221,28 +236,28 @@ } - void GenType::visit( StructInstType *structInst ) { - typeString = structInst->get_name() + handleGeneric( structInst ) + " " + typeString; + void GenType::postvisit( StructInstType * structInst ) { + typeString = structInst->name + handleGeneric( structInst ) + " " + typeString; if ( genC ) typeString = "struct " + typeString; handleQualifiers( structInst ); } - void GenType::visit( UnionInstType *unionInst ) { - typeString = unionInst->get_name() + handleGeneric( unionInst ) + " " + typeString; + void GenType::postvisit( UnionInstType * unionInst ) { + typeString = unionInst->name + handleGeneric( unionInst ) + " " + typeString; if ( genC ) typeString = "union " + typeString; handleQualifiers( unionInst ); } - void GenType::visit( EnumInstType *enumInst ) { - typeString = enumInst->get_name() + " " + typeString; + void GenType::postvisit( EnumInstType * enumInst ) { + typeString = enumInst->name + " " + typeString; if ( genC ) typeString = "enum " + typeString; handleQualifiers( enumInst ); } - void GenType::visit( TypeInstType *typeInst ) { - typeString = typeInst->get_name() + " " + typeString; + void GenType::postvisit( TypeInstType * typeInst ) { + typeString = typeInst->name + " " + typeString; handleQualifiers( typeInst ); } - void GenType::visit( TupleType * tupleType ) { + void GenType::postvisit( TupleType * tupleType ) { assertf( ! genC, "Tuple types should not reach code generation." ); unsigned int i = 0; @@ -257,10 +272,10 @@ } - void GenType::visit( VarArgsType *varArgsType ) { + void GenType::postvisit( VarArgsType * varArgsType ) { typeString = "__builtin_va_list " + typeString; handleQualifiers( varArgsType ); } - void GenType::visit( ZeroType *zeroType ) { + void GenType::postvisit( ZeroType * zeroType ) { // ideally these wouldn't hit codegen at all, but should be safe to make them ints typeString = (pretty ? "zero_t " : "long int ") + typeString; @@ -268,5 +283,5 @@ } - void GenType::visit( OneType *oneType ) { + void GenType::postvisit( OneType * oneType ) { // ideally these wouldn't hit codegen at all, but should be safe to make them ints typeString = (pretty ? "one_t " : "long int ") + typeString; @@ -274,5 +289,5 @@ } - void GenType::handleQualifiers( Type *type ) { + void GenType::handleQualifiers( Type * type ) { if ( type->get_const() ) { typeString = "const " + typeString; Index: src/CodeTools/DeclStats.cc =================================================================== --- src/CodeTools/DeclStats.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/CodeTools/DeclStats.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -23,4 +23,5 @@ #include // for pair, make_pair +#include "Common/PassVisitor.h" #include "Common/SemanticError.h" // for SemanticError #include "Common/VectorMap.h" // for VectorMap @@ -35,5 +36,5 @@ namespace CodeTools { - class DeclStats : public Visitor { + struct DeclStats : public WithShortCircuiting { template static void sum(T& a, const T& b) { a += b; } @@ -61,10 +62,14 @@ struct ArgPackStats { - VectorMap n; ///< Count of decls with each number of elements - VectorMap n_basic; ///< Count of decls with each number of basic type elements - VectorMap n_poly; ///< Count of decls with each number of polymorphic elements - std::map p_basic; ///< Count of decls with each percentage of basic type elements - std::map p_poly; ///< Count of decls with each percentage of polymorphic elements - VectorMap n_types; ///< Count of decls with each number of distinct types in the pack + VectorMap n; ///< Count of decls with each number of elements + VectorMap n_basic; ///< Count of decls with each number of basic type elements + VectorMap n_generic; ///< Count of decls with each number of generic type elements + VectorMap n_poly; ///< Count of decls with each number of polymorphic elements + VectorMap n_compound; ///< Count of decls with each number of non-generic compound types + std::map p_basic; ///< Count of decls with each percentage of basic type elements + std::map p_generic; ///< Count of decls with each percentage of generic type elements + std::map p_poly; ///< Count of decls with each percentage of polymorphic elements + std::map p_compound; ///< Count of decls with each percentage of non-generic compound type elements + VectorMap n_types; ///< Count of decls with each number of distinct types in the pack /// Count of decls with each percentage of new types in lists. /// Types used in the parameter list that recur in the return list are not considered to be new. @@ -74,7 +79,11 @@ sum(n, o.n); sum(n_basic, o.n_basic); + sum(n_generic, o.n_generic); sum(n_poly, o.n_poly); + sum(n_compound, o.n_compound); sum(p_basic, o.p_basic); + sum(p_generic, o.p_generic); sum(p_poly, o.p_poly); + sum(p_compound, o.p_compound); sum(n_types, o.n_types); sum(p_new, o.p_new); @@ -88,12 +97,20 @@ /// Count of declarations with each number of assertion parameters VectorMap n_type_params; + /// Count of generic types with each number of type parameters + VectorMap n_generic_params; + /// Count of maximum nesting depth of types + VectorMap n_generic_nesting; /// Count of declarations with each name std::unordered_map by_name; /// Count of uses of each basic type std::unordered_map basic_type_names; - /// Count of uses of each non-basic type + /// Count of uses of each generic type name (includes "*", "[]", "(*)", "[,]") + std::unordered_map generic_type_names; + /// Count of uses of each non-generic aggregate type std::unordered_map compound_type_names; /// Count of decls using each basic type std::unordered_map basic_type_decls; + /// Count of decls using each generic type (includes "*", "[]", "(*)", "[,]") + std::unordered_map generic_type_decls; /// Count of decls using each compound type std::unordered_map compound_type_decls; @@ -110,5 +127,8 @@ ArgPackStats assn_returns; - Stats() : n_decls(0), n_type_params(), by_name(), basic_type_names(), compound_type_names(), basic_type_decls(), compound_type_decls(), params(), returns(), n_assns(), assn_params(), assn_returns() {} + Stats() : n_decls(0), n_type_params(), n_generic_params(), n_generic_nesting(), + by_name(), basic_type_names(), generic_type_names(), compound_type_names(), + basic_type_decls(), generic_type_decls(), compound_type_decls(), params(), + returns(), n_assns(), assn_params(), assn_returns() {} public: @@ -116,8 +136,12 @@ sum( n_decls, o.n_decls ); sum( n_type_params, o.n_type_params ); + sum( n_generic_params, o.n_generic_params ); + sum( n_generic_nesting, o.n_generic_nesting ); sum( by_name, o.by_name ); sum( basic_type_names, o.basic_type_names ); + sum( generic_type_names, o.generic_type_names ); sum( compound_type_names, o.compound_type_names ); sum( basic_type_decls, o.basic_type_decls ); + sum( generic_type_decls, o.generic_type_decls ); sum( compound_type_decls, o.compound_type_decls ); sum( params, o.params ); @@ -131,5 +155,10 @@ }; - Stats for_linkage[LinkageSpec::NoOfSpecs]; ///< Stores separate stats per linkage + /// number of counting bins for linkages + static const unsigned n_named_specs = 8; + /// map from total number of specs to bins + static const unsigned ind_for_linkage[16]; + + Stats for_linkage[n_named_specs]; ///< Stores separate stats per linkage std::unordered_set seen_names; ///< Stores manglenames already seen to avoid double-counting Stats total; @@ -137,11 +166,149 @@ std::map, unsigned> exprs_by_fanout_at_depth; + void countType( const std::string& name, unsigned& n, std::unordered_map& names, std::unordered_map& decls, + std::unordered_set& elSeen ) { + ++n; + ++names[ name ]; + if ( elSeen.insert( name ).second ) { ++decls[ name ]; } + } + + void update_max( unsigned& max, unsigned crnt ) { + if ( crnt > max ) max = crnt; + } + + void analyzeSubtype( Type* ty, Stats& stats, std::unordered_set& elSeen, + unsigned& n_poly, bool& seen_poly, unsigned& max_depth, unsigned depth ) { + unsigned x; + analyzeType( ty, stats, elSeen, x, x, n_poly, x, seen_poly, max_depth, depth + 1 ); + } + + void analyzeSubtypes( std::list& tys, Stats& stats, + std::unordered_set& elSeen, unsigned& n_poly, bool& seen_poly, + unsigned& max_depth, unsigned depth, unsigned& n_subs ) { + for ( DeclarationWithType* dwt : tys ) { + Type* ty = dwt->get_type(); + n_subs += (unsigned)( dynamic_cast(ty) != nullptr ); + analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth ); + } + } + + void analyzeSubtypes( std::list& tys, Stats& stats, + std::unordered_set& elSeen, unsigned& n_poly, bool& seen_poly, + unsigned& max_depth, unsigned depth ) { + for ( Expression* expr : tys ) { + TypeExpr* texpr = dynamic_cast(expr); + if ( ! texpr ) continue; + Type* ty = texpr->get_type(); + analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth ); + } + } + + void analyzeSubtypes( std::list& tys, Stats& stats, + std::unordered_set& elSeen, unsigned& n_poly, bool& seen_poly, + unsigned& max_depth, unsigned depth ) { + for ( Type* ty : tys ) { + analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth ); + } + } + + void analyzeType( Type* ty, Stats& stats, std::unordered_set& elSeen, + unsigned& n_basic, unsigned& n_generic, unsigned& n_poly, unsigned& n_agg, + bool& seen_poly, unsigned& max_depth, unsigned depth = 0 ) { + if ( BasicType* bt = dynamic_cast(ty) ) { + std::string name = BasicType::typeNames[ bt->get_kind() ]; + countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen ); + update_max( max_depth, depth ); + } else if ( PointerType* pt = dynamic_cast(ty) ) { + std::string name = "*"; + countType( + name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen); + analyzeSubtype( + pt->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth ); + ++stats.n_generic_params.at( 1 ); + } else if ( ArrayType* at = dynamic_cast(ty) ) { + std::string name = "[]"; + countType( + name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen); + analyzeSubtype( + at->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth ); + ++stats.n_generic_params.at( 1 ); + } else if ( ReferenceType* rt = dynamic_cast(ty) ) { + std::string name = "&"; + countType( + name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen); + analyzeSubtype( + rt->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth ); + ++stats.n_generic_params.at( 1 ); + } else if ( FunctionType* ft = dynamic_cast(ty) ) { + std::string name = "(*)"; + countType( + name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen); + unsigned n_subs = 0; + analyzeSubtypes( + ft->get_returnVals(), stats, elSeen, n_poly, seen_poly, max_depth, depth, + n_subs ); + analyzeSubtypes( + ft->get_parameters(), stats, elSeen, n_poly, seen_poly, max_depth, depth, + n_subs ); + ++stats.n_generic_params.at( n_subs ); + } else if ( TypeInstType* vt = dynamic_cast(ty) ) { + if ( ! seen_poly ) { + ++n_poly; + seen_poly = true; + } + countType( + vt->get_name(), n_agg, stats.compound_type_names, stats.compound_type_decls, + elSeen ); + update_max( max_depth, depth ); + } else if ( ReferenceToType* st = dynamic_cast(ty) ) { + std::list& params = st->get_parameters(); + if ( params.empty() ) { + countType( + st->get_name(), n_agg, stats.compound_type_names, + stats.compound_type_decls, elSeen ); + update_max( max_depth, depth ); + } else { + countType( + st->get_name(), n_generic, stats.generic_type_names, + stats.generic_type_decls, elSeen); + analyzeSubtypes( params, stats, elSeen, n_poly, seen_poly, max_depth, depth ); + ++stats.n_generic_params.at( params.size() ); + } + } else if ( TupleType* tt = dynamic_cast(ty) ) { + std::string name = "[,]"; + countType( + name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen); + analyzeSubtypes( + tt->get_types(), stats, elSeen, n_poly, seen_poly, max_depth, depth ); + ++stats.n_generic_params.at( tt->size() ); + } else if ( dynamic_cast(ty) ) { + std::string name = "..."; + countType( + name, n_agg, stats.compound_type_names, stats.compound_type_decls, elSeen ); + update_max( max_depth, depth ); + } else if ( dynamic_cast(ty) ) { + std::string name = "0"; + countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen ); + update_max( max_depth, depth ); + } else if ( dynamic_cast(ty) ) { + std::string name = "1"; + countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen ); + update_max( max_depth, depth ); + } + } + /// Update arg pack stats based on a declaration list - void analyze( Stats& stats, std::unordered_set& seen, ArgPackStats& pstats, std::list& decls ) { + void analyze( Stats& stats, std::unordered_set& seen, + std::unordered_set& elSeen, ArgPackStats& pstats, + std::list& decls ) { std::unordered_set types; - unsigned n = 0; ///< number of args/returns - unsigned n_basic = 0; ///< number of basic types - unsigned n_poly = 0; ///< number of polymorphic types - unsigned n_new = 0; ///< number of new types + unsigned n = 0; ///< number of args/returns + unsigned n_basic = 0; ///< number of basic types + unsigned n_generic = 0; ///< number of generic types (includes "*", "&", "[]", "(*)", "[,]") + unsigned n_poly = 0; ///< number of polymorphic types + unsigned n_agg = 0; ///< number of non-generic aggregate types + unsigned n_new = 0; ///< number of new types + for ( auto decl : decls ) { Type* dt = decl->get_type(); @@ -152,29 +319,24 @@ dt->print( ss ); types.insert( ss.str() ); - bool this_new = seen.insert( ss.str() ).second; - if ( this_new ) { ++n_new; } - - if ( dynamic_cast( dt ) ) { - ++n_basic; - ++stats.basic_type_names[ ss.str() ]; - if ( this_new ) { - ++stats.basic_type_decls[ ss.str() ]; - } - } else if ( GenPoly::hasPolyBase( dt ) ) { - ++n_poly; - } else { - ++stats.compound_type_names[ ss.str() ]; - if ( this_new ) { - ++stats.compound_type_decls[ ss.str() ]; - } - } - } + if ( seen.insert( ss.str() ).second ) { ++n_new; } + + bool seen_poly = false; + unsigned max_depth = 0; + analyzeType( + dt, stats, elSeen, n_basic, n_generic, n_poly, n_agg, seen_poly, max_depth ); + ++stats.n_generic_nesting.at( max_depth ); + } + ++pstats.n.at( n ); ++pstats.n_basic.at( n_basic ); + ++pstats.n_generic.at( n_generic ); ++pstats.n_poly.at( n_poly ); + ++pstats.n_compound.at( n_agg ); if ( n > 0 ) { ++pstats.p_basic[ n_basic*100/n ]; + ++pstats.p_generic[ n_generic*100/n ]; ++pstats.p_poly[ n_poly*100/n ]; - ++pstats.p_new[ n_new*100/n ]; + ++pstats.p_compound[ n_agg*100/n ]; + if ( n > 1 ) ++pstats.p_new[ (n_new-1)*100/(n-1) ]; } ++pstats.n_types.at( types.size() ); @@ -183,6 +345,7 @@ void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) { std::unordered_set seen; - analyze( stats, seen, params, fnTy->get_parameters() ); - analyze( stats, seen, returns, fnTy->get_returnVals() ); + std::unordered_set elSeen; + analyze( stats, seen, elSeen, params, fnTy->get_parameters() ); + analyze( stats, seen, elSeen, returns, fnTy->get_returnVals() ); } @@ -200,46 +363,37 @@ public: - using Visitor::visit; - - virtual void visit( FunctionDecl *decl ) { + void previsit( FunctionDecl *decl ) { // skip if already seen declaration for this function - const std::string& mangleName = decl->get_mangleName().empty() ? decl->get_name() : decl->get_mangleName(); - if ( ! seen_names.insert( mangleName ).second ) { - maybeAccept( decl->get_statements(), *this ); - return; - } - - Stats& stats = for_linkage[ decl->get_linkage() ]; - - ++stats.n_decls; - FunctionType* fnTy = decl->get_functionType(); - const Type::ForallList& forall = fnTy->get_forall(); - ++stats.n_type_params.at( forall.size() ); - unsigned n_assns = 0; - for ( TypeDecl* fdecl : forall ) { - n_assns += fdecl->get_assertions().size(); - for ( DeclarationWithType* assn : fdecl->get_assertions() ) { - FunctionType *assnTy = 0; - if ( ObjectDecl *assnObj = dynamic_cast(assn) ) { - if ( PointerType *ptrTy = dynamic_cast(assnObj->get_type()) ) { - assnTy = dynamic_cast(ptrTy->get_base()); - } else assnTy = dynamic_cast(assnObj->get_type()); - } else if ( FunctionDecl *assnDecl = dynamic_cast(assn) ) { - assnTy = assnDecl->get_functionType(); + const std::string& mangleName = decl->get_mangleName().empty() ? decl->name : decl->get_mangleName(); + if ( seen_names.insert( mangleName ).second ) { + Stats& stats = for_linkage[ ind_for_linkage[ decl->linkage ] ]; + + ++stats.n_decls; + FunctionType* fnTy = decl->type; + const Type::ForallList& forall = fnTy->forall; + ++stats.n_type_params.at( forall.size() ); + unsigned n_assns = 0; + for ( TypeDecl* fdecl : forall ) { + n_assns += fdecl->assertions.size(); + for ( DeclarationWithType* assn : fdecl->assertions ) { + FunctionType *assnTy = nullptr; + if ( ObjectDecl *assnObj = dynamic_cast(assn) ) { + if ( PointerType *ptrTy = dynamic_cast(assnObj->get_type()) ) { + assnTy = dynamic_cast(ptrTy->base); + } else assnTy = dynamic_cast(assnObj->get_type()); + } else if ( FunctionDecl *assnDecl = dynamic_cast(assn) ) { + assnTy = assnDecl->type; + } + if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns ); } - if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns ); - } - } - ++stats.n_assns[ n_assns ]; - - ++stats.by_name[ decl->get_name() ]; - - analyzeFunc( fnTy, stats, stats.params, stats.returns ); - - // analyze expressions in decl statements - maybeAccept( decl->get_statements(), *this ); - } - - virtual void visit( UntypedExpr *expr ) { + } + ++stats.n_assns[ n_assns ]; + ++stats.by_name[ decl->name ]; + analyzeFunc( fnTy, stats, stats.params, stats.returns ); + } + } + + void previsit( UntypedExpr *expr ) { + visit_children = false; analyzeExpr( expr, 0 ); } @@ -272,10 +426,10 @@ template void printAllHisto( const std::string& name, F extract ) { - VectorMap histos[LinkageSpec::NoOfSpecs]; + VectorMap histos[n_named_specs]; VectorMap thisto; for ( const auto& entry : extract(total) ) { ++thisto.at( entry.second ); } - for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) { + for ( unsigned i = 0; i < n_named_specs; ++i ) { // can't be a higher count in one of the sub-histograms than the total histos[i].reserve( thisto.size() ); @@ -295,10 +449,10 @@ template void printAllSparseHisto( const std::string& name, F extract ) { - std::map histos[LinkageSpec::NoOfSpecs]; + std::map histos[n_named_specs]; std::map thisto; for ( const auto& entry : extract(total) ) { ++thisto[ entry.second ]; } - for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) { + for ( unsigned i = 0; i < n_named_specs; ++i ) { for ( const auto& entry : extract(for_linkage[i]) ) { ++histos[i][entry.second]; } } @@ -307,5 +461,5 @@ const auto& key = entry.first; std::cout << "\"" << name << "\"," << key; - for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) { + for ( unsigned i = 0; i < n_named_specs; ++i ) { auto it = histos[i].find( key ); if ( it == histos[i].end() ) std::cout << ",0"; @@ -319,8 +473,12 @@ void printAllPack( const std::string& name, F extract ) { printAllMap("n_basic_" + name, [&extract](const Stats& stats) { return extract(stats).n_basic; }); + printAllMap("n_generic_" + name, [&extract](const Stats& stats) { return extract(stats).n_generic; }); printAllMap("n_poly_" + name, [&extract](const Stats& stats) { return extract(stats).n_poly; }); + printAllMap("n_compound_" + name, [&extract](const Stats& stats) { return extract(stats).n_compound; }); printAllMap("n_" + name, [&extract](const Stats& stats) { return extract(stats).n; }); printAllMap("%_basic_" + name, [&extract](const Stats& stats) { return extract(stats).p_basic; }); + printAllMap("%_generic_" + name, [&extract](const Stats& stats) { return extract(stats).p_generic; }); printAllMap("%_poly_" + name, [&extract](const Stats& stats) { return extract(stats).p_poly; }); + printAllMap("%_compound_" + name, [&extract](const Stats& stats) { return extract(stats).p_compound; }); printAllMap("n_distinct_types_" + name, [&extract](const Stats& stats) { return extract(stats).n_types; }); printAllMap("%_new_types_in_" + name, [&extract](const Stats& stats) { return extract(stats).p_new; }); @@ -342,7 +500,9 @@ } - std::cout << ",,\"intrinsic\",\"Cforall\",\"C\",\"autogen\",\"builtin\",\"TOTAL\"" << std::endl; + std::cout << ",,\"intrinsic\",\"Cforall\",\"C\",\"autogen\",\"compiler\",\"builtinCFA\",\"builtinC\",\"other\",\"TOTAL\"" << std::endl; printAllMap("n_type_params", [](const Stats& stats) { return stats.n_type_params; }); + printAllMap("n_generic_params", [](const Stats& stats) { return stats.n_generic_params; }); + printAllMap("n_generic_nesting", [](const Stats& stats) { return stats.n_generic_nesting; }); printAll("n_decls", [](const Stats& stats) { return stats.n_decls; }); printAll("unique_names", [](const Stats& stats) { return stats.by_name.size(); }); @@ -351,4 +511,7 @@ printAllSparseHisto("basic_type_uses", [](const Stats& stats) { return stats.basic_type_names; }); printAllSparseHisto("decls_using_basic_type", [](const Stats& stats) { return stats.basic_type_decls; }); + printAll("generic_type_names", [](const Stats& stats) { return stats.generic_type_names.size(); }); + printAllSparseHisto("generic_type_uses", [](const Stats& stats) { return stats.generic_type_names; }); + printAllSparseHisto("decls_using_generic_type", [](const Stats& stats) { return stats.generic_type_decls; }); printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); }); printAllSparseHisto("compound_type_uses", [](const Stats& stats) { return stats.compound_type_names; }); @@ -365,8 +528,11 @@ }; + const unsigned DeclStats::ind_for_linkage[] + = { 7, 7, 2, 1, 7, 7, 7, 3, 4, 7, 6, 5, 7, 7, 7, 0 }; + void printDeclStats( std::list< Declaration * > &translationUnit ) { - DeclStats stats; + PassVisitor stats; acceptAll( translationUnit, stats ); - stats.print(); + stats.pass.print(); } Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/Common/PassVisitor.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -19,5 +19,6 @@ #include "SynTree/Expression.h" #include "SynTree/Constant.h" -#include "SynTree/TypeSubstitution.h" + +class TypeSubstitution; #include "PassVisitor.proto.h" @@ -118,4 +119,6 @@ virtual void visit( StmtExpr * stmtExpr ) override final; virtual void visit( UniqueExpr * uniqueExpr ) override final; + virtual void visit( UntypedInitExpr * initExpr ) override final; + virtual void visit( InitExpr * initExpr ) override final; virtual void visit( VoidType * basicType ) override final; @@ -210,4 +213,6 @@ virtual Expression * mutate( StmtExpr * stmtExpr ) override final; virtual Expression * mutate( UniqueExpr * uniqueExpr ) override final; + virtual Expression * mutate( UntypedInitExpr * initExpr ) override final; + virtual Expression * mutate( InitExpr * initExpr ) override final; virtual Type * mutate( VoidType * basicType ) override final; @@ -403,3 +408,4 @@ }; +#include "SynTree/TypeSubstitution.h" #include "PassVisitor.impl.h" Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/Common/PassVisitor.impl.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -62,5 +62,5 @@ template< typename pass_type > -static inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) { +inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) { DeclList_t* beforeDecls = visitor.get_beforeDecls(); DeclList_t* afterDecls = visitor.get_afterDecls(); @@ -90,5 +90,5 @@ template< typename pass_type > -static inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) { +inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) { DeclList_t* beforeDecls = mutator.get_beforeDecls(); DeclList_t* afterDecls = mutator.get_afterDecls(); @@ -1853,4 +1853,54 @@ } +//-------------------------------------------------------------------------- +// UntypedInitExpr +template< typename pass_type > +void PassVisitor< pass_type >::visit( UntypedInitExpr * node ) { + VISIT_START( node ); + + indexerScopedAccept( node->result, *this ); + maybeAccept_impl ( node->expr , *this ); + // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver. + + VISIT_END( node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( UntypedInitExpr * node ) { + MUTATE_START( node ); + + indexerScopedMutate( node->env , *this ); + indexerScopedMutate( node->result, *this ); + maybeMutate_impl ( node->expr , *this ); + // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver. + + MUTATE_END( Expression, node ); +} + +//-------------------------------------------------------------------------- +// InitExpr +template< typename pass_type > +void PassVisitor< pass_type >::visit( InitExpr * node ) { + VISIT_START( node ); + + indexerScopedAccept( node->result, *this ); + maybeAccept_impl ( node->expr , *this ); + maybeAccept_impl ( node->designation, *this ); + + VISIT_END( node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( InitExpr * node ) { + MUTATE_START( node ); + + indexerScopedMutate( node->env , *this ); + indexerScopedMutate( node->result, *this ); + maybeMutate_impl ( node->expr , *this ); + maybeMutate_impl ( node->designation, *this ); + + MUTATE_END( Expression, node ); +} + template< typename pass_type > void PassVisitor< pass_type >::visit( VoidType * node ) { Index: src/Concurrency/Waitfor.cc =================================================================== --- src/Concurrency/Waitfor.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/Concurrency/Waitfor.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -507,6 +507,8 @@ new ListInit({ new SingleInit( new AddressExpr( new VariableExpr( index ) ) ), - new SingleInit( new VariableExpr( acceptables ) ), - new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) ) + new ListInit({ + new SingleInit( new VariableExpr( acceptables ) ), + new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) ) + }) }) ); Index: src/ControlStruct/ExceptTranslate.cc =================================================================== --- src/ControlStruct/ExceptTranslate.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ControlStruct/ExceptTranslate.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -316,6 +316,5 @@ VarExprReplacer::DeclMap mapping; mapping[ handler_decl ] = local_except; - VarExprReplacer mapper( mapping ); - handler->get_body()->accept( mapper ); + VarExprReplacer::replace( handler->body, mapping ); } Index: src/ControlStruct/LabelFixer.cc =================================================================== --- src/ControlStruct/LabelFixer.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ControlStruct/LabelFixer.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -44,5 +44,5 @@ void LabelFixer::postvisit( FunctionDecl * functionDecl ) { - MLEMutator mlemut( resolveJumps(), generator ); + PassVisitor mlemut( resolveJumps(), generator ); functionDecl->acceptMutator( mlemut ); } Index: src/ControlStruct/MLEMutator.cc =================================================================== --- src/ControlStruct/MLEMutator.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ControlStruct/MLEMutator.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -46,5 +46,5 @@ void MLEMutator::fixBlock( std::list< Statement * > &kids ) { for ( std::list< Statement * >::iterator k = kids.begin(); k != kids.end(); k++ ) { - *k = (*k)->acceptMutator(*this); + *k = (*k)->acceptMutator(*visitor); if ( ! get_breakLabel().empty() ) { @@ -57,6 +57,7 @@ } - CompoundStmt* MLEMutator::mutate( CompoundStmt *cmpndStmt ) { - bool labeledBlock = !(cmpndStmt->get_labels().empty()); + void MLEMutator::premutate( CompoundStmt *cmpndStmt ) { + visit_children = false; + bool labeledBlock = !(cmpndStmt->labels.empty()); if ( labeledBlock ) { Label brkLabel = generator->newLabel("blockBreak", cmpndStmt); @@ -65,5 +66,5 @@ // a child statement may set the break label - if they do, attach it to the next statement - std::list< Statement * > &kids = cmpndStmt->get_kids(); + std::list< Statement * > &kids = cmpndStmt->kids; fixBlock( kids ); @@ -75,88 +76,6 @@ enclosingControlStructures.pop_back(); } // if - - return cmpndStmt; - } - - template< typename LoopClass > - Statement *MLEMutator::handleLoopStmt( LoopClass *loopStmt ) { - // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine - // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested - // loops - Label brkLabel = generator->newLabel("loopBreak", loopStmt); - Label contLabel = generator->newLabel("loopContinue", loopStmt); - enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) ); - loopStmt->set_body ( loopStmt->get_body()->acceptMutator( *this ) ); - - assert( ! enclosingControlStructures.empty() ); - Entry &e = enclosingControlStructures.back(); - // sanity check that the enclosing loops have been popped correctly - assert ( e == loopStmt ); - - // this will take the necessary steps to add definitions of the previous two labels, if they are used. - loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) ); - enclosingControlStructures.pop_back(); - - return loopStmt; - } - - Statement *MLEMutator::mutate( CaseStmt *caseStmt ) { - caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) ); - fixBlock( caseStmt->get_statements() ); - - return caseStmt; - } - - template< typename IfClass > - Statement *MLEMutator::handleIfStmt( IfClass *ifStmt ) { - // generate a label for breaking out of a labeled if - bool labeledBlock = !(ifStmt->get_labels().empty()); - if ( labeledBlock ) { - Label brkLabel = generator->newLabel("blockBreak", ifStmt); - enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) ); - } // if - - Parent::mutate( ifStmt ); - - if ( labeledBlock ) { - if ( ! enclosingControlStructures.back().useBreakExit().empty() ) { - set_breakLabel( enclosingControlStructures.back().useBreakExit() ); - } // if - enclosingControlStructures.pop_back(); - } // if - return ifStmt; - } - - template< typename SwitchClass > - Statement *MLEMutator::handleSwitchStmt( SwitchClass *switchStmt ) { - // generate a label for breaking out of a labeled switch - Label brkLabel = generator->newLabel("switchBreak", switchStmt); - enclosingControlStructures.push_back( Entry(switchStmt, brkLabel) ); - mutateAll( switchStmt->get_statements(), *this ); - - Entry &e = enclosingControlStructures.back(); - assert ( e == switchStmt ); - - // only generate break label if labeled break is used - if ( e.isBreakUsed() ) { - // for the purposes of keeping switch statements uniform (i.e. all statements that are direct children of a - // switch should be CastStmts), append the exit label + break to the last case statement; create a default - // case if there are no cases - std::list< Statement * > &statements = switchStmt->get_statements(); - if ( statements.empty() ) { - statements.push_back( CaseStmt::makeDefault() ); - } // if - - if ( CaseStmt * c = dynamic_cast< CaseStmt * >( statements.back() ) ) { - Statement * stmt = new BranchStmt( Label("brkLabel"), BranchStmt::Break ); - stmt->labels.push_back( brkLabel ); - c->get_statements().push_back( stmt ); - } else assert(0); // as of this point, all statements of a switch are still CaseStmts - } // if - - assert ( enclosingControlStructures.back() == switchStmt ); - enclosingControlStructures.pop_back(); - return switchStmt; - } + } + void addUnused( Statement * stmt, const Label & originalTarget ) { @@ -179,6 +98,6 @@ - Statement *MLEMutator::mutate( BranchStmt *branchStmt ) throw ( SemanticError ) { - std::string originalTarget = branchStmt->get_originalTarget(); + Statement *MLEMutator::postmutate( BranchStmt *branchStmt ) throw ( SemanticError ) { + std::string originalTarget = branchStmt->originalTarget; std::list< Entry >::reverse_iterator targetEntry; @@ -215,5 +134,5 @@ // branch error checks, get the appropriate label name and create a goto Label exitLabel; - switch ( branchStmt->get_type() ) { + switch ( branchStmt->type ) { case BranchStmt::Break: assert( targetEntry->useBreakExit() != ""); @@ -229,5 +148,5 @@ // add unused attribute to label to silence warnings - addUnused( targetEntry->get_controlStructure(), branchStmt->get_originalTarget() ); + addUnused( targetEntry->get_controlStructure(), branchStmt->originalTarget ); // transform break/continue statements into goto to simplify later handling of branches @@ -260,18 +179,99 @@ } - Statement *MLEMutator::mutate( WhileStmt *whileStmt ) { - return handleLoopStmt( whileStmt ); - } - - Statement *MLEMutator::mutate( ForStmt *forStmt ) { - return handleLoopStmt( forStmt ); - } - - Statement *MLEMutator::mutate( IfStmt *ifStmt ) { - return handleIfStmt( ifStmt ); - } - - Statement *MLEMutator::mutate( SwitchStmt *switchStmt ) { - return handleSwitchStmt( switchStmt ); + template< typename LoopClass > + void MLEMutator::prehandleLoopStmt( LoopClass * loopStmt ) { + // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine + // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested + // loops + Label brkLabel = generator->newLabel("loopBreak", loopStmt); + Label contLabel = generator->newLabel("loopContinue", loopStmt); + enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) ); + } + + template< typename LoopClass > + Statement * MLEMutator::posthandleLoopStmt( LoopClass * loopStmt ) { + assert( ! enclosingControlStructures.empty() ); + Entry &e = enclosingControlStructures.back(); + // sanity check that the enclosing loops have been popped correctly + assert ( e == loopStmt ); + + // this will take the necessary steps to add definitions of the previous two labels, if they are used. + loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) ); + enclosingControlStructures.pop_back(); + return loopStmt; + } + + void MLEMutator::premutate( WhileStmt * whileStmt ) { + return prehandleLoopStmt( whileStmt ); + } + + void MLEMutator::premutate( ForStmt * forStmt ) { + return prehandleLoopStmt( forStmt ); + } + + Statement * MLEMutator::postmutate( WhileStmt * whileStmt ) { + return posthandleLoopStmt( whileStmt ); + } + + Statement * MLEMutator::postmutate( ForStmt * forStmt ) { + return posthandleLoopStmt( forStmt ); + } + + void MLEMutator::premutate( IfStmt * ifStmt ) { + // generate a label for breaking out of a labeled if + bool labeledBlock = !(ifStmt->get_labels().empty()); + if ( labeledBlock ) { + Label brkLabel = generator->newLabel("blockBreak", ifStmt); + enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) ); + } // if + } + + Statement * MLEMutator::postmutate( IfStmt * ifStmt ) { + bool labeledBlock = !(ifStmt->get_labels().empty()); + if ( labeledBlock ) { + if ( ! enclosingControlStructures.back().useBreakExit().empty() ) { + set_breakLabel( enclosingControlStructures.back().useBreakExit() ); + } // if + enclosingControlStructures.pop_back(); + } // if + return ifStmt; + } + + void MLEMutator::premutate( CaseStmt *caseStmt ) { + visit_children = false; + caseStmt->condition = maybeMutate( caseStmt->condition, *visitor ); + fixBlock( caseStmt->stmts ); + } + + void MLEMutator::premutate( SwitchStmt *switchStmt ) { + // generate a label for breaking out of a labeled switch + Label brkLabel = generator->newLabel("switchBreak", switchStmt); + enclosingControlStructures.push_back( Entry(switchStmt, brkLabel) ); + } + + Statement * MLEMutator::postmutate( SwitchStmt * switchStmt ) { + Entry &e = enclosingControlStructures.back(); + assert ( e == switchStmt ); + + // only generate break label if labeled break is used + if ( e.isBreakUsed() ) { + // for the purposes of keeping switch statements uniform (i.e. all statements that are direct children of a + // switch should be CastStmts), append the exit label + break to the last case statement; create a default + // case if there are no cases + std::list< Statement * > &statements = switchStmt->statements; + if ( statements.empty() ) { + statements.push_back( CaseStmt::makeDefault() ); + } // if + + if ( CaseStmt * c = dynamic_cast< CaseStmt * >( statements.back() ) ) { + Statement * stmt = new BranchStmt( Label("brkLabel"), BranchStmt::Break ); + stmt->labels.push_back( e.useBreakExit() ); + c->stmts.push_back( stmt ); + } else assert(0); // as of this point, all statements of a switch are still CaseStmts + } // if + + assert ( enclosingControlStructures.back() == switchStmt ); + enclosingControlStructures.pop_back(); + return switchStmt; } } // namespace ControlStruct Index: src/ControlStruct/MLEMutator.h =================================================================== --- src/ControlStruct/MLEMutator.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ControlStruct/MLEMutator.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -20,4 +20,5 @@ #include // for string +#include "Common/PassVisitor.h" #include "Common/SemanticError.h" // for SemanticError #include "SynTree/Label.h" // for Label @@ -26,21 +27,24 @@ namespace ControlStruct { -class LabelGenerator; + class LabelGenerator; - class MLEMutator : public Mutator { + class MLEMutator : public WithVisitorRef, public WithShortCircuiting { class Entry; - typedef Mutator Parent; public: MLEMutator( std::map *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {} ~MLEMutator(); - virtual CompoundStmt *mutate( CompoundStmt *cmpndStmt ) override; - virtual Statement *mutate( WhileStmt *whileStmt ) override; - virtual Statement *mutate( ForStmt *forStmt ) override; - virtual Statement *mutate( BranchStmt *branchStmt ) throw ( SemanticError ) override; - virtual Statement *mutate( CaseStmt *caseStmt ) override; - virtual Statement *mutate( IfStmt *ifStmt ) override; - virtual Statement *mutate( SwitchStmt *switchStmt ) override; + void premutate( CompoundStmt *cmpndStmt ); + Statement * postmutate( BranchStmt *branchStmt ) throw ( SemanticError ); + void premutate( WhileStmt *whileStmt ); + Statement * postmutate( WhileStmt *whileStmt ); + void premutate( ForStmt *forStmt ); + Statement * postmutate( ForStmt *forStmt ); + void premutate( CaseStmt *caseStmt ); + void premutate( IfStmt *ifStmt ); + Statement * postmutate( IfStmt *ifStmt ); + void premutate( SwitchStmt *switchStmt ); + Statement * postmutate( SwitchStmt *switchStmt ); Statement *mutateLoop( Statement *bodyLoop, Entry &e ); @@ -54,8 +58,8 @@ loop( _loop ), breakExit( _breakExit ), contExit( _contExit ), breakUsed(false), contUsed(false) {} - bool operator==( const Statement *stmt ) { return ( loop == stmt ); } - bool operator!=( const Statement *stmt ) { return ( loop != stmt ); } + bool operator==( const Statement *stmt ) { return loop == stmt; } + bool operator!=( const Statement *stmt ) { return loop != stmt; } - bool operator==( const Entry &other ) { return ( loop == other.get_controlStructure() ); } + bool operator==( const Entry &other ) { return loop == other.get_controlStructure(); } Statement *get_controlStructure() const { return loop; } @@ -78,11 +82,8 @@ template< typename LoopClass > - Statement *handleLoopStmt( LoopClass *loopStmt ); + void prehandleLoopStmt( LoopClass * loopStmt ); - template< typename IfClass > - Statement *handleIfStmt( IfClass *switchStmt ); - - template< typename SwitchClass > - Statement *handleSwitchStmt( SwitchClass *switchStmt ); + template< typename LoopClass > + Statement * posthandleLoopStmt( LoopClass * loopStmt ); void fixBlock( std::list< Statement * > &kids ); Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/GenPoly/Box.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -302,5 +302,5 @@ Expression *makeOp( const std::string &name, Expression *arg ) { UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) ); - expr->get_args().push_back( arg ); + expr->args.push_back( arg ); return expr; } @@ -309,6 +309,6 @@ Expression *makeOp( const std::string &name, Expression *lhs, Expression *rhs ) { UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) ); - expr->get_args().push_back( lhs ); - expr->get_args().push_back( rhs ); + expr->args.push_back( lhs ); + expr->args.push_back( rhs ); return expr; } @@ -316,5 +316,5 @@ /// Returns the dereference of a local pointer variable Expression *derefVar( ObjectDecl *var ) { - return makeOp( "*?", new VariableExpr( var ) ); + return UntypedExpr::createDeref( new VariableExpr( var ) ); } @@ -831,6 +831,7 @@ if ( ! isPolyType( arg->get_type() ) ) { UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) ); - deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) ); - deref->set_result( arg->get_type()->clone() ); + deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) ); + deref->result = arg->get_type()->clone(); + deref->result->set_lvalue( true ); return deref; } // if Index: src/GenPoly/Lvalue.cc =================================================================== --- src/GenPoly/Lvalue.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/GenPoly/Lvalue.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -47,11 +47,11 @@ 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() ); + deref->result = new PointerType( Type::Qualifiers(), deref->result ); + Type * base = InitTweak::getPointerBase( arg->result ); + assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->result ).c_str() ); ApplicationExpr * ret = new ApplicationExpr( deref, { arg } ); - delete ret->get_result(); - ret->set_result( base->clone() ); - ret->get_result()->set_lvalue( true ); + delete ret->result; + ret->result = base->clone(); + ret->result->set_lvalue( true ); return ret; } else { @@ -308,31 +308,35 @@ int diff = depth1-depth2; if ( diff == 0 ) { + // conversion between references of the same depth 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(); + // conversion from reference to reference with less depth (e.g. int && -> int &): add dereferences + Expression * ret = castExpr->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 ); + ret->env = castExpr->env; + delete ret->result; + ret->result = castExpr->result; + ret->result->set_lvalue( true ); // ensure result is lvalue + castExpr->env = nullptr; + castExpr->arg = nullptr; + castExpr->result = nullptr; delete castExpr; return ret; } else if ( diff > 0 ) { - Expression * ret = castExpr->get_arg(); + // conversion from reference to reference with more depth (e.g. int & -> int &&): add address-of + Expression * ret = castExpr->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 ); + ret->env = castExpr->env; + delete ret->result; + ret->result = castExpr->result; + castExpr->env = nullptr; + castExpr->arg = nullptr; + castExpr->result = nullptr; delete castExpr; return ret; @@ -342,5 +346,5 @@ PRINT( std::cerr << castExpr << std::endl; ) return castExpr; - } else if ( castExpr->get_arg()->get_result()->get_lvalue() ) { + } else if ( castExpr->arg->result->get_lvalue() ) { // conversion from lvalue to reference // xxx - keep cast, but turn into pointer cast?? @@ -348,18 +352,18 @@ PRINT( std::cerr << "convert lvalue to reference -- &" << std::endl; - std::cerr << castExpr->get_arg() << std::endl; + std::cerr << castExpr->arg << std::endl; ) - AddressExpr * ret = new AddressExpr( castExpr->get_arg() ); - if ( refType->get_base()->get_qualifiers() != castExpr->get_arg()->get_result()->get_qualifiers() ) { + AddressExpr * ret = new AddressExpr( castExpr->arg ); + if ( refType->base->get_qualifiers() != castExpr->arg->result->get_qualifiers() ) { // must keep cast if cast-to type is different from the actual type - castExpr->set_arg( ret ); + castExpr->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 ); + ret->env = castExpr->env; + delete ret->result; + ret->result = castExpr->result; + castExpr->env = nullptr; + castExpr->arg = nullptr; + castExpr->result = nullptr; delete castExpr; return ret; @@ -368,5 +372,5 @@ } 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() ) ) { + } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->arg->result ) ) { (void)refType; // conversion from reference to rvalue @@ -375,6 +379,6 @@ std::cerr << "was = " << castExpr << std::endl; ) - Expression * ret = castExpr->get_arg(); - TypeSubstitution * env = castExpr->get_env(); + Expression * ret = castExpr->arg; + TypeSubstitution * env = castExpr->env; castExpr->set_env( nullptr ); if ( ! isIntrinsicReference( ret ) ) { @@ -382,12 +386,13 @@ ret = mkDeref( ret ); } - if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) { + if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->result, castExpr->arg->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 ); + ret->result = castExpr->result->clone(); + ret->result->set_lvalue( true ); // ensure result is lvalue + castExpr->arg = nullptr; delete castExpr; } else { // must keep cast if types are different - castExpr->set_arg( ret ); + castExpr->arg = ret; ret = castExpr; } Index: src/GenPoly/ScrubTyVars.cc =================================================================== --- src/GenPoly/ScrubTyVars.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/GenPoly/ScrubTyVars.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -25,5 +25,5 @@ namespace GenPoly { - Type * ScrubTyVars::mutate( TypeInstType *typeInst ) { + Type * ScrubTyVars::postmutate( TypeInstType * typeInst ) { if ( ! tyVars ) { if ( typeInst->get_isFtype() ) { @@ -31,5 +31,5 @@ return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ); } else { - PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) ); + PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) ); delete typeInst; return ret; @@ -37,5 +37,5 @@ } - TyVarMap::const_iterator tyVar = tyVars->find( typeInst->get_name() ); + TyVarMap::const_iterator tyVar = tyVars->find( typeInst->name ); if ( tyVar != tyVars->end() ) { switch ( tyVar->second.kind ) { @@ -43,5 +43,5 @@ case TypeDecl::Ttype: { - PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) ); + PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) ); delete typeInst; return ret; @@ -55,7 +55,7 @@ } - Type * ScrubTyVars::mutateAggregateType( Type *ty ) { + Type * ScrubTyVars::mutateAggregateType( Type * ty ) { if ( shouldScrub( ty ) ) { - PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) ); + PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) ); delete ty; return ret; @@ -64,54 +64,49 @@ } - Type * ScrubTyVars::mutate( StructInstType *structInst ) { + Type * ScrubTyVars::postmutate( StructInstType * structInst ) { return mutateAggregateType( structInst ); } - Type * ScrubTyVars::mutate( UnionInstType *unionInst ) { + Type * ScrubTyVars::postmutate( UnionInstType * unionInst ) { return mutateAggregateType( unionInst ); } - Expression * ScrubTyVars::mutate( SizeofExpr *szeof ) { + void ScrubTyVars::primeBaseScrub( Type * type ) { + // need to determine whether type needs to be scrubbed to determine whether + // automatic recursion is necessary + if ( Type * t = shouldScrub( type ) ) { + visit_children = false; + GuardValue( dynType ); + dynType = t; + } + } + + Expression * ScrubTyVars::postmutate( SizeofExpr * szeof ) { // sizeof( T ) => _sizeof_T parameter, which is the size of T - if ( Type *dynType = shouldScrub( szeof->get_type() ) ) { + if ( dynType ) { Expression *expr = new NameExpr( sizeofName( mangleType( dynType ) ) ); return expr; - } else { - return Mutator::mutate( szeof ); } // if + return szeof; } - Expression * ScrubTyVars::mutate( AlignofExpr *algnof ) { + Expression * ScrubTyVars::postmutate( AlignofExpr * algnof ) { // alignof( T ) => _alignof_T parameter, which is the alignment of T - if ( Type *dynType = shouldScrub( algnof->get_type() ) ) { + if ( dynType ) { Expression *expr = new NameExpr( alignofName( mangleType( dynType ) ) ); return expr; - } else { - return Mutator::mutate( algnof ); } // if + return algnof; } - Type * ScrubTyVars::mutate( PointerType *pointer ) { -// // special case of shouldScrub that takes all TypeInstType pointer bases, even if they're not dynamic -// Type *base = pointer->get_base(); -// Type *dynType = 0; -// if ( dynamicOnly ) { -// if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( base ) ) { -// if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) { dynType = typeInst; } -// } else { -// dynType = isDynType( base, tyVars ); -// } -// } else { -// dynType = isPolyType( base, tyVars ); -// } -// if ( dynType ) { - if ( Type *dynType = shouldScrub( pointer->get_base() ) ) { - Type *ret = dynType->acceptMutator( *this ); + Type * ScrubTyVars::postmutate( PointerType * pointer ) { + if ( dynType ) { + Type * ret = dynType->acceptMutator( *visitor ); ret->get_qualifiers() |= pointer->get_qualifiers(); - pointer->set_base( 0 ); + pointer->base = nullptr; delete pointer; return ret; } - return Mutator::mutate( pointer ); + return pointer; } } // namespace GenPoly Index: src/GenPoly/ScrubTyVars.h =================================================================== --- src/GenPoly/ScrubTyVars.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/GenPoly/ScrubTyVars.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -18,4 +18,5 @@ #include // for assert +#include "Common/PassVisitor.h" #include "GenPoly.h" // for TyVarMap, isPolyType, isDynType #include "SynTree/Mutator.h" // for Mutator @@ -27,5 +28,5 @@ namespace GenPoly { - class ScrubTyVars : public Mutator { + struct ScrubTyVars : public WithVisitorRef, public WithShortCircuiting, public WithGuards { /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables enum ScrubMode { FromMap, DynamicFromMap, All }; @@ -51,10 +52,20 @@ static SynTreeClass *scrubAll( SynTreeClass *target ); - virtual Type* mutate( TypeInstType *typeInst ); - virtual Type* mutate( StructInstType *structInst ); - virtual Type* mutate( UnionInstType *unionInst ); - virtual Expression* mutate( SizeofExpr *szeof ); - virtual Expression* mutate( AlignofExpr *algnof ); - virtual Type* mutate( PointerType *pointer ); + /// determine if children should be visited based on whether base type should be scrubbed. + void primeBaseScrub( Type * ); + + void premutate( TypeInstType * ) { visit_children = false; } + void premutate( StructInstType * ) { visit_children = false; } + void premutate( UnionInstType * ) { visit_children = false; } + void premutate( SizeofExpr * szeof ) { primeBaseScrub( szeof->type ); } + void premutate( AlignofExpr * algnof ) { primeBaseScrub( algnof->type ); } + void premutate( PointerType * pointer ) { primeBaseScrub( pointer->base ); } + + Type * postmutate( TypeInstType * typeInst ); + Type * postmutate( StructInstType * structInst ); + Type * postmutate( UnionInstType * unionInst ); + Expression * postmutate( SizeofExpr * szeof ); + Expression * postmutate( AlignofExpr * algnof ); + Type * postmutate( PointerType * pointer ); private: @@ -75,9 +86,11 @@ const TyVarMap *tyVars; ///< Type variables to scrub ScrubMode mode; ///< which type variables to scrub? [FromMap] + + Type * dynType = nullptr; ///< result of shouldScrub }; template< typename SynTreeClass > SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) { - ScrubTyVars scrubber( tyVars ); + PassVisitor scrubber( tyVars ); return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) ); } @@ -85,5 +98,5 @@ template< typename SynTreeClass > SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) { - ScrubTyVars scrubber( tyVars, ScrubTyVars::DynamicFromMap ); + PassVisitor scrubber( tyVars, ScrubTyVars::DynamicFromMap ); return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) ); } @@ -91,5 +104,5 @@ template< typename SynTreeClass > SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) { - ScrubTyVars scrubber; + PassVisitor scrubber; return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) ); } Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/InitTweak/FixInit.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -197,5 +197,5 @@ }; - struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer { + struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer, public WithVisitorRef { /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors /// for any member that is missing a corresponding ctor/dtor call. @@ -203,9 +203,13 @@ static void generate( std::list< Declaration * > & translationUnit ); - void previsit( FunctionDecl * funcDecl ); - void postvisit( FunctionDecl * funcDecl ); - - void previsit( MemberExpr * memberExpr ); - void previsit( ApplicationExpr * appExpr ); + void premutate( FunctionDecl * funcDecl ); + DeclarationWithType * postmutate( FunctionDecl * funcDecl ); + + void premutate( MemberExpr * memberExpr ); + void premutate( ApplicationExpr * appExpr ); + + /// Note: this post mutate used to be in a separate visitor. If this pass breaks, one place to examine is whether it is + /// okay for this part of the recursion to occur alongside the rest. + Expression * postmutate( UntypedExpr * expr ); SemanticError errors; @@ -220,19 +224,4 @@ bool isCtor = false; // true if current function is a constructor StructDecl * structDecl = nullptr; - }; - - // very simple resolver-like mutator class - used to - // resolve UntypedExprs that are found within newly - // generated constructor/destructor calls - class MutatingResolver final : public Mutator { - public: - MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {} - - using Mutator::mutate; - virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override; - virtual Expression* mutate( UntypedExpr *untypedExpr ) override; - - private: - SymTab::Indexer & indexer; }; @@ -315,5 +304,5 @@ void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) { PassVisitor warner; - acceptAll( translationUnit, warner ); + mutateAll( translationUnit, warner ); } @@ -950,5 +939,5 @@ } - void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) { + void GenStructMemberCalls::premutate( FunctionDecl * funcDecl ) { GuardValue( function ); GuardValue( unhandled ); @@ -984,5 +973,5 @@ } - void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) { + DeclarationWithType * GenStructMemberCalls::postmutate( FunctionDecl * funcDecl ) { // remove the unhandled objects from usedUninit, because a call is inserted // to handle them - only objects that are later constructed are used uninitialized. @@ -1038,7 +1027,6 @@ Statement * callStmt = stmt.front(); - MutatingResolver resolver( indexer ); try { - callStmt->acceptMutator( resolver ); + callStmt->acceptMutator( *visitor ); if ( isCtor ) { function->get_statements()->push_front( callStmt ); @@ -1056,4 +1044,5 @@ throw errors; } + return funcDecl; } @@ -1081,5 +1070,5 @@ } - void GenStructMemberCalls::previsit( ApplicationExpr * appExpr ) { + void GenStructMemberCalls::premutate( ApplicationExpr * appExpr ) { if ( ! checkWarnings( function ) ) { visit_children = false; @@ -1106,5 +1095,5 @@ } - void GenStructMemberCalls::previsit( MemberExpr * memberExpr ) { + void GenStructMemberCalls::premutate( MemberExpr * memberExpr ) { if ( ! checkWarnings( function ) || ! isCtor ) { visit_children = false; @@ -1134,13 +1123,5 @@ } - DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) { - // add object to the indexer assumes that there will be no name collisions - // in generated code. If this changes, add mutate methods for entities with - // scope and call {enter,leave}Scope explicitly. - indexer.addId( objectDecl ); - return objectDecl; - } - - Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) { + Expression * GenStructMemberCalls::postmutate( UntypedExpr * untypedExpr ) { Expression * newExpr = untypedExpr; ResolvExpr::findVoidExpression( newExpr, indexer ); Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/AlternativeFinder.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -60,4 +60,65 @@ namespace ResolvExpr { + struct AlternativeFinder::Finder : public WithShortCircuiting { + Finder( AlternativeFinder & altFinder ) : altFinder( altFinder ), indexer( altFinder.indexer ), alternatives( altFinder.alternatives ), env( altFinder.env ), targetType( altFinder.targetType ) {} + + void previsit( BaseSyntaxNode * ) { visit_children = false; } + + void postvisit( ApplicationExpr * applicationExpr ); + void postvisit( UntypedExpr * untypedExpr ); + void postvisit( AddressExpr * addressExpr ); + void postvisit( LabelAddressExpr * labelExpr ); + void postvisit( CastExpr * castExpr ); + void postvisit( VirtualCastExpr * castExpr ); + void postvisit( UntypedMemberExpr * memberExpr ); + void postvisit( MemberExpr * memberExpr ); + void postvisit( NameExpr * variableExpr ); + void postvisit( VariableExpr * variableExpr ); + void postvisit( ConstantExpr * constantExpr ); + void postvisit( SizeofExpr * sizeofExpr ); + void postvisit( AlignofExpr * alignofExpr ); + void postvisit( UntypedOffsetofExpr * offsetofExpr ); + void postvisit( OffsetofExpr * offsetofExpr ); + void postvisit( OffsetPackExpr * offsetPackExpr ); + void postvisit( AttrExpr * attrExpr ); + void postvisit( LogicalExpr * logicalExpr ); + void postvisit( ConditionalExpr * conditionalExpr ); + void postvisit( CommaExpr * commaExpr ); + void postvisit( ImplicitCopyCtorExpr * impCpCtorExpr ); + void postvisit( ConstructorExpr * ctorExpr ); + void postvisit( RangeExpr * rangeExpr ); + void postvisit( UntypedTupleExpr * tupleExpr ); + void postvisit( TupleExpr * tupleExpr ); + void postvisit( TupleIndexExpr * tupleExpr ); + void postvisit( TupleAssignExpr * tupleExpr ); + void postvisit( UniqueExpr * unqExpr ); + void postvisit( StmtExpr * stmtExpr ); + void postvisit( UntypedInitExpr * initExpr ); + + /// Adds alternatives for anonymous members + void addAnonConversions( const Alternative & alt ); + /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member + template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); + /// Adds alternatives for member expressions where the left side has tuple type + void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); + /// Adds alternatives for offsetof expressions, given the base type and name of the member + template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name ); + /// Takes a final result and checks if its assertions can be satisfied + template + void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector& results, OutputIterator out ); + /// Finds matching alternatives for a function, given a set of arguments + template + void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out ); + /// Checks if assertion parameters match for a new alternative + template< typename OutputIterator > + void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ); + private: + AlternativeFinder & altFinder; + const SymTab::Indexer &indexer; + AltList & alternatives; + const TypeEnvironment &env; + Type *& targetType; + }; + Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) { CastExpr *castToVoid = new CastExpr( expr ); @@ -152,5 +213,5 @@ void renameTypes( Expression *expr ) { - expr->get_result()->accept( global_renamer ); + renameTyVars( expr->result ); } } // namespace @@ -185,5 +246,6 @@ void AlternativeFinder::find( Expression *expr, bool adjust, bool prune, bool failFast ) { - expr->accept( *this ); + PassVisitor finder( *this ); + expr->accept( finder ); if ( failFast && alternatives.empty() ) { PRINT( @@ -244,5 +306,5 @@ } - void AlternativeFinder::addAnonConversions( const Alternative & alt ) { + void AlternativeFinder::Finder::addAnonConversions( const Alternative & alt ) { // adds anonymous member interpretations whenever an aggregate value type is seen. // 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 @@ -265,5 +327,5 @@ template< typename StructOrUnionType > - void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { + void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { // by this point, member must be a name expr NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ); @@ -284,5 +346,5 @@ } - void AlternativeFinder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { + void AlternativeFinder::Finder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) { // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning @@ -308,5 +370,5 @@ } - void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) { + void AlternativeFinder::Finder::postvisit( ApplicationExpr *applicationExpr ) { alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) ); } @@ -485,5 +547,5 @@ Type *adjType = candidate->get_type()->clone(); adjustExprType( adjType, newEnv, indexer ); - adjType->accept( global_renamer ); + renameTyVars( adjType ); PRINT( std::cerr << "unifying "; @@ -541,5 +603,5 @@ template< typename OutputIterator > - void AlternativeFinder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) { + void AlternativeFinder::Finder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) { // PRINT( // std::cerr << "inferParameters: assertions needed are" << std::endl; @@ -595,5 +657,5 @@ ArgPack() - : parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0), + : parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0), tupleStart(0), nextExpl(0), explAlt(0) {} @@ -706,5 +768,5 @@ if ( nTuples > 0 || ! results[i].expr ) { - // first iteration or no expression to clone, + // first iteration or no expression to clone, // push empty tuple expression newResult.parent = i; @@ -892,5 +954,5 @@ template - void AlternativeFinder::validateFunctionAlternative( const Alternative &func, ArgPack& result, + void AlternativeFinder::Finder::validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector& results, OutputIterator out ) { ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() ); @@ -915,5 +977,5 @@ template - void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, + void AlternativeFinder::Finder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs &args, OutputIterator out ) { OpenVarSet funcOpenVars; @@ -1022,5 +1084,5 @@ } - void AlternativeFinder::visit( UntypedExpr *untypedExpr ) { + void AlternativeFinder::Finder::postvisit( UntypedExpr *untypedExpr ) { AlternativeFinder funcFinder( indexer, env ); funcFinder.findWithAdjustment( untypedExpr->get_function() ); @@ -1029,10 +1091,10 @@ std::vector< AlternativeFinder > argAlternatives; - findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(), + altFinder.findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(), back_inserter( argAlternatives ) ); // take care of possible tuple assignments // if not tuple assignment, assignment is taken care of as a normal function call - Tuples::handleTupleAssignment( *this, untypedExpr, argAlternatives ); + Tuples::handleTupleAssignment( altFinder, untypedExpr, argAlternatives ); // find function operators @@ -1172,5 +1234,5 @@ // fix this issue in a more robust way. targetType = nullptr; - visit( untypedExpr ); + postvisit( untypedExpr ); } } @@ -1181,5 +1243,5 @@ } - void AlternativeFinder::visit( AddressExpr *addressExpr ) { + void AlternativeFinder::Finder::postvisit( AddressExpr *addressExpr ) { AlternativeFinder finder( indexer, env ); finder.find( addressExpr->get_arg() ); @@ -1192,5 +1254,5 @@ } - void AlternativeFinder::visit( LabelAddressExpr * expr ) { + void AlternativeFinder::Finder::postvisit( LabelAddressExpr * expr ) { alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } ); } @@ -1223,5 +1285,5 @@ } - void AlternativeFinder::visit( CastExpr *castExpr ) { + void AlternativeFinder::Finder::postvisit( CastExpr *castExpr ) { Type *& toType = castExpr->get_result(); assert( toType ); @@ -1278,5 +1340,5 @@ } - void AlternativeFinder::visit( VirtualCastExpr * castExpr ) { + void AlternativeFinder::Finder::postvisit( VirtualCastExpr * castExpr ) { assertf( castExpr->get_result(), "Implicate virtual cast targets not yet supported." ); AlternativeFinder finder( indexer, env ); @@ -1290,5 +1352,5 @@ } - void AlternativeFinder::visit( UntypedMemberExpr *memberExpr ) { + void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) { AlternativeFinder funcFinder( indexer, env ); funcFinder.findWithAdjustment( memberExpr->get_aggregate() ); @@ -1312,9 +1374,9 @@ } - void AlternativeFinder::visit( MemberExpr *memberExpr ) { + void AlternativeFinder::Finder::postvisit( MemberExpr *memberExpr ) { alternatives.push_back( Alternative( memberExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( NameExpr *nameExpr ) { + void AlternativeFinder::Finder::postvisit( NameExpr *nameExpr ) { std::list< SymTab::Indexer::IdData > declList; indexer.lookupId( nameExpr->get_name(), declList ); @@ -1337,5 +1399,5 @@ } - void AlternativeFinder::visit( VariableExpr *variableExpr ) { + void AlternativeFinder::Finder::postvisit( VariableExpr *variableExpr ) { // not sufficient to clone here, because variable's type may have changed // since the VariableExpr was originally created. @@ -1343,9 +1405,9 @@ } - void AlternativeFinder::visit( ConstantExpr *constantExpr ) { + void AlternativeFinder::Finder::postvisit( ConstantExpr *constantExpr ) { alternatives.push_back( Alternative( constantExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) { + void AlternativeFinder::Finder::postvisit( SizeofExpr *sizeofExpr ) { if ( sizeofExpr->get_isType() ) { Type * newType = sizeofExpr->get_type()->clone(); @@ -1368,5 +1430,5 @@ } - void AlternativeFinder::visit( AlignofExpr *alignofExpr ) { + void AlternativeFinder::Finder::postvisit( AlignofExpr *alignofExpr ) { if ( alignofExpr->get_isType() ) { Type * newType = alignofExpr->get_type()->clone(); @@ -1390,5 +1452,5 @@ template< typename StructOrUnionType > - void AlternativeFinder::addOffsetof( StructOrUnionType *aggInst, const std::string &name ) { + void AlternativeFinder::Finder::addOffsetof( StructOrUnionType *aggInst, const std::string &name ) { std::list< Declaration* > members; aggInst->lookup( name, members ); @@ -1403,5 +1465,5 @@ } - void AlternativeFinder::visit( UntypedOffsetofExpr *offsetofExpr ) { + void AlternativeFinder::Finder::postvisit( UntypedOffsetofExpr *offsetofExpr ) { AlternativeFinder funcFinder( indexer, env ); // xxx - resolveTypeof? @@ -1413,9 +1475,9 @@ } - void AlternativeFinder::visit( OffsetofExpr *offsetofExpr ) { + void AlternativeFinder::Finder::postvisit( OffsetofExpr *offsetofExpr ) { alternatives.push_back( Alternative( offsetofExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( OffsetPackExpr *offsetPackExpr ) { + void AlternativeFinder::Finder::postvisit( OffsetPackExpr *offsetPackExpr ) { alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) ); } @@ -1444,5 +1506,5 @@ } - void AlternativeFinder::visit( AttrExpr *attrExpr ) { + void AlternativeFinder::Finder::postvisit( AttrExpr *attrExpr ) { // assume no 'pointer-to-attribute' NameExpr *nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() ); @@ -1458,5 +1520,5 @@ if ( function->get_parameters().size() == 1 ) { if ( attrExpr->get_isType() ) { - resolveAttr( data, function, attrExpr->get_type(), env, *this ); + resolveAttr( data, function, attrExpr->get_type(), env, altFinder); } else { AlternativeFinder finder( indexer, env ); @@ -1464,5 +1526,5 @@ for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) { if ( choice->expr->get_result()->size() == 1 ) { - resolveAttr(data, function, choice->expr->get_result(), choice->env, *this ); + resolveAttr(data, function, choice->expr->get_result(), choice->env, altFinder ); } // fi } // for @@ -1479,34 +1541,48 @@ } - void AlternativeFinder::visit( LogicalExpr *logicalExpr ) { + void AlternativeFinder::Finder::postvisit( LogicalExpr *logicalExpr ) { AlternativeFinder firstFinder( indexer, env ); firstFinder.findWithAdjustment( logicalExpr->get_arg1() ); + if ( firstFinder.alternatives.empty() ) return; + AlternativeFinder secondFinder( indexer, env ); + secondFinder.findWithAdjustment( logicalExpr->get_arg2() ); + if ( secondFinder.alternatives.empty() ) return; for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) { - AlternativeFinder secondFinder( indexer, first->env ); - secondFinder.findWithAdjustment( logicalExpr->get_arg2() ); for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) { + TypeEnvironment compositeEnv; + compositeEnv.simpleCombine( first->env ); + compositeEnv.simpleCombine( second->env ); + LogicalExpr *newExpr = new LogicalExpr( first->expr->clone(), second->expr->clone(), logicalExpr->get_isAnd() ); - alternatives.push_back( Alternative( newExpr, second->env, first->cost + second->cost ) ); - } - } - } - - void AlternativeFinder::visit( ConditionalExpr *conditionalExpr ) { + alternatives.push_back( Alternative( newExpr, compositeEnv, first->cost + second->cost ) ); + } + } + } + + void AlternativeFinder::Finder::postvisit( ConditionalExpr *conditionalExpr ) { // find alternatives for condition AlternativeFinder firstFinder( indexer, env ); firstFinder.findWithAdjustment( conditionalExpr->get_arg1() ); + if ( firstFinder.alternatives.empty() ) return; + // find alternatives for true expression + AlternativeFinder secondFinder( indexer, env ); + secondFinder.findWithAdjustment( conditionalExpr->get_arg2() ); + if ( secondFinder.alternatives.empty() ) return; + // find alterantives for false expression + AlternativeFinder thirdFinder( indexer, env ); + thirdFinder.findWithAdjustment( conditionalExpr->get_arg3() ); + if ( thirdFinder.alternatives.empty() ) return; for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) { - // find alternatives for true expression - AlternativeFinder secondFinder( indexer, first->env ); - secondFinder.findWithAdjustment( conditionalExpr->get_arg2() ); for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) { - // find alterantives for false expression - AlternativeFinder thirdFinder( indexer, second->env ); - thirdFinder.findWithAdjustment( conditionalExpr->get_arg3() ); for ( AltList::const_iterator third = thirdFinder.alternatives.begin(); third != thirdFinder.alternatives.end(); ++third ) { + TypeEnvironment compositeEnv; + compositeEnv.simpleCombine( first->env ); + compositeEnv.simpleCombine( second->env ); + compositeEnv.simpleCombine( third->env ); + // unify true and false types, then infer parameters to produce new alternatives OpenVarSet openVars; AssertionSet needAssertions, haveAssertions; - Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost ); + Alternative newAlt( 0, compositeEnv, first->cost + second->cost + third->cost ); Type* commonType = nullptr; if ( unify( second->expr->get_result(), third->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) { @@ -1524,5 +1600,5 @@ } - void AlternativeFinder::visit( CommaExpr *commaExpr ) { + void AlternativeFinder::Finder::postvisit( CommaExpr *commaExpr ) { TypeEnvironment newEnv( env ); Expression *newFirstArg = resolveInVoidContext( commaExpr->get_arg1(), indexer, newEnv ); @@ -1535,15 +1611,20 @@ } - void AlternativeFinder::visit( RangeExpr * rangeExpr ) { + void AlternativeFinder::Finder::postvisit( RangeExpr * rangeExpr ) { // resolve low and high, accept alternatives whose low and high types unify AlternativeFinder firstFinder( indexer, env ); firstFinder.findWithAdjustment( rangeExpr->get_low() ); + if ( firstFinder.alternatives.empty() ) return; + AlternativeFinder secondFinder( indexer, env ); + secondFinder.findWithAdjustment( rangeExpr->get_high() ); + if ( secondFinder.alternatives.empty() ) return; for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) { - AlternativeFinder secondFinder( indexer, first->env ); - secondFinder.findWithAdjustment( rangeExpr->get_high() ); for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) { + TypeEnvironment compositeEnv; + compositeEnv.simpleCombine( first->env ); + compositeEnv.simpleCombine( second->env ); OpenVarSet openVars; AssertionSet needAssertions, haveAssertions; - Alternative newAlt( 0, second->env, first->cost + second->cost ); + Alternative newAlt( 0, compositeEnv, first->cost + second->cost ); Type* commonType = nullptr; if ( unify( first->expr->get_result(), second->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) { @@ -1557,7 +1638,7 @@ } - void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) { + void AlternativeFinder::Finder::postvisit( UntypedTupleExpr *tupleExpr ) { std::vector< AlternativeFinder > subExprAlternatives; - findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), + altFinder.findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) ); std::vector< AltList > possibilities; @@ -1575,13 +1656,13 @@ } - void AlternativeFinder::visit( TupleExpr *tupleExpr ) { + void AlternativeFinder::Finder::postvisit( TupleExpr *tupleExpr ) { alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( ImplicitCopyCtorExpr * impCpCtorExpr ) { + void AlternativeFinder::Finder::postvisit( ImplicitCopyCtorExpr * impCpCtorExpr ) { alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( ConstructorExpr * ctorExpr ) { + void AlternativeFinder::Finder::postvisit( ConstructorExpr * ctorExpr ) { AlternativeFinder finder( indexer, env ); // don't prune here, since it's guaranteed all alternatives will have the same type @@ -1593,13 +1674,13 @@ } - void AlternativeFinder::visit( TupleIndexExpr *tupleExpr ) { + void AlternativeFinder::Finder::postvisit( TupleIndexExpr *tupleExpr ) { alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( TupleAssignExpr *tupleAssignExpr ) { + void AlternativeFinder::Finder::postvisit( TupleAssignExpr *tupleAssignExpr ) { alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( UniqueExpr *unqExpr ) { + void AlternativeFinder::Finder::postvisit( UniqueExpr *unqExpr ) { AlternativeFinder finder( indexer, env ); finder.findWithAdjustment( unqExpr->get_expr() ); @@ -1611,5 +1692,5 @@ } - void AlternativeFinder::visit( StmtExpr *stmtExpr ) { + void AlternativeFinder::Finder::postvisit( StmtExpr *stmtExpr ) { StmtExpr * newStmtExpr = stmtExpr->clone(); ResolvExpr::resolveStmtExpr( newStmtExpr, indexer ); @@ -1618,8 +1699,10 @@ } - void AlternativeFinder::visit( UntypedInitExpr *initExpr ) { + void AlternativeFinder::Finder::postvisit( UntypedInitExpr *initExpr ) { // handle each option like a cast AltList candidates; - PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; ) + PRINT( + std::cerr << "untyped init expr: " << initExpr << std::endl; + ) // O(N^2) checks of d-types with e-types for ( InitAlternative & initAlt : initExpr->get_initAlts() ) { @@ -1637,5 +1720,7 @@ AssertionSet needAssertions, haveAssertions; OpenVarSet openVars; // find things in env that don't have a "representative type" and claim those are open vars? - PRINT( std::cerr << " @ " << toType << " " << initAlt.designation << std::endl; ) + PRINT( + std::cerr << " @ " << toType << " " << initAlt.designation << std::endl; + ) // It's possible that a cast can throw away some values in a multiply-valued expression. (An example is a // cast-to-void, which casts from one value to zero.) Figure out the prefix of the subexpression results Index: src/ResolvExpr/AlternativeFinder.h =================================================================== --- src/ResolvExpr/AlternativeFinder.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/AlternativeFinder.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -38,5 +38,5 @@ using ExplodedArgs = std::vector< std::vector< ExplodedActual > >; - class AlternativeFinder : public Visitor { + class AlternativeFinder { public: AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env ); @@ -94,53 +94,5 @@ void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out ); private: - virtual void visit( ApplicationExpr *applicationExpr ); - virtual void visit( UntypedExpr *untypedExpr ); - virtual void visit( AddressExpr *addressExpr ); - virtual void visit( LabelAddressExpr *labelExpr ); - virtual void visit( CastExpr *castExpr ); - virtual void visit( VirtualCastExpr *castExpr ); - virtual void visit( UntypedMemberExpr *memberExpr ); - virtual void visit( MemberExpr *memberExpr ); - virtual void visit( NameExpr *variableExpr ); - virtual void visit( VariableExpr *variableExpr ); - virtual void visit( ConstantExpr *constantExpr ); - virtual void visit( SizeofExpr *sizeofExpr ); - virtual void visit( AlignofExpr *alignofExpr ); - virtual void visit( UntypedOffsetofExpr *offsetofExpr ); - virtual void visit( OffsetofExpr *offsetofExpr ); - virtual void visit( OffsetPackExpr *offsetPackExpr ); - virtual void visit( AttrExpr *attrExpr ); - virtual void visit( LogicalExpr *logicalExpr ); - virtual void visit( ConditionalExpr *conditionalExpr ); - virtual void visit( CommaExpr *commaExpr ); - virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ); - virtual void visit( ConstructorExpr * ctorExpr ); - virtual void visit( RangeExpr * rangeExpr ); - virtual void visit( UntypedTupleExpr *tupleExpr ); - virtual void visit( TupleExpr *tupleExpr ); - virtual void visit( TupleIndexExpr *tupleExpr ); - virtual void visit( TupleAssignExpr *tupleExpr ); - virtual void visit( UniqueExpr *unqExpr ); - virtual void visit( StmtExpr *stmtExpr ); - virtual void visit( UntypedInitExpr *initExpr ); - - /// Adds alternatives for anonymous members - void addAnonConversions( const Alternative & alt ); - /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member - template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); - /// Adds alternatives for member expressions where the left side has tuple type - void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); - /// Adds alternatives for offsetof expressions, given the base type and name of the member - template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name ); - /// Takes a final result and checks if its assertions can be satisfied - template - void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector& results, OutputIterator out ); - /// Finds matching alternatives for a function, given a set of arguments - template - void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out ); - /// Checks if assertion parameters match for a new alternative - template< typename OutputIterator > - void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ); - + struct Finder; const SymTab::Indexer &indexer; AltList alternatives; Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/CastCost.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -31,10 +31,12 @@ namespace ResolvExpr { - class CastCost : public ConversionCost { + struct CastCost : public ConversionCost { public: - CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ); + CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ); - virtual void visit( BasicType *basicType ); - virtual void visit( PointerType *pointerType ); + using ConversionCost::previsit; + using ConversionCost::postvisit; + void postvisit( BasicType * basicType ); + void postvisit( PointerType * pointerType ); }; @@ -52,6 +54,6 @@ // all typedefs should be gone by this point TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType ); - if ( type->get_base() ) { - return castCost( src, type->get_base(), indexer, env ) + Cost::safe; + if ( type->base ) { + return castCost( src, type->base, indexer, env ) + Cost::safe; } // if } // if @@ -74,24 +76,24 @@ } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) { PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; ) - return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer & indexer) { + return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) { return ptrsCastable( t1, t2, env, indexer ); }); } else { - CastCost converter( dest, indexer, env ); + PassVisitor converter( dest, indexer, env, castCost ); src->accept( converter ); - if ( converter.get_cost() == Cost::infinity ) { + if ( converter.pass.get_cost() == Cost::infinity ) { return Cost::infinity; } else { // xxx - why are we adding cost 0 here? - return converter.get_cost() + Cost::zero; + return converter.pass.get_cost() + Cost::zero; } // if } // if } - CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) - : ConversionCost( dest, indexer, env ) { + CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ) + : ConversionCost( dest, indexer, env, costFunc ) { } - void CastCost::visit( BasicType *basicType ) { + void CastCost::postvisit( BasicType *basicType ) { PointerType *destAsPointer = dynamic_cast< PointerType* >( dest ); if ( destAsPointer && basicType->isInteger() ) { @@ -103,13 +105,13 @@ } - void CastCost::visit( PointerType *pointerType ) { + void CastCost::postvisit( PointerType *pointerType ) { if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) { - if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) { + if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) { cost = Cost::safe; } else { TypeEnvironment newEnv( env ); - newEnv.add( pointerType->get_forall() ); - newEnv.add( pointerType->get_base()->get_forall() ); - int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer ); + newEnv.add( pointerType->forall ); + newEnv.add( pointerType->base->forall ); + int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer ); if ( castResult > 0 ) { cost = Cost::safe; Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/CommonType.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -18,4 +18,5 @@ #include // for pair +#include "Common/PassVisitor.h" #include "ResolvExpr/TypeEnvironment.h" // for OpenVarSet, AssertionSet #include "SymTab/Indexer.h" // for Indexer @@ -29,25 +30,27 @@ namespace ResolvExpr { - class CommonType : public Visitor { - public: + struct CommonType : public WithShortCircuiting { CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ); Type *get_result() const { return result; } + + void previsit( BaseSyntaxNode * ) { visit_children = false; } + + void postvisit( VoidType * voidType ); + void postvisit( BasicType * basicType ); + void postvisit( PointerType * pointerType ); + void postvisit( ArrayType * arrayType ); + void postvisit( ReferenceType * refType ); + void postvisit( FunctionType * functionType ); + void postvisit( StructInstType * aggregateUseType ); + void postvisit( UnionInstType * aggregateUseType ); + void postvisit( EnumInstType * aggregateUseType ); + void postvisit( TraitInstType * aggregateUseType ); + void postvisit( TypeInstType * aggregateUseType ); + void postvisit( TupleType * tupleType ); + void postvisit( VarArgsType * varArgsType ); + void postvisit( ZeroType * zeroType ); + void postvisit( OneType * oneType ); + private: - virtual void visit( VoidType *voidType ); - virtual void visit( BasicType *basicType ); - 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 ); - virtual void visit( UnionInstType *aggregateUseType ); - virtual void visit( EnumInstType *aggregateUseType ); - virtual void visit( TraitInstType *aggregateUseType ); - virtual void visit( TypeInstType *aggregateUseType ); - virtual void visit( TupleType *tupleType ); - virtual void visit( VarArgsType *varArgsType ); - virtual void visit( ZeroType *zeroType ); - virtual void visit( OneType *oneType ); - template< typename Pointer > void getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ); template< typename RefType > void handleRefType( RefType *inst, Type *other ); @@ -80,5 +83,5 @@ 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 ); + PassVisitor visitor( type2, widenFirst, widenSecond, indexer, env, openVars ); int depth1 = type1->referenceDepth(); @@ -116,5 +119,5 @@ type1->accept( visitor ); - Type *result = visitor.get_result(); + Type *result = visitor.pass.get_result(); if ( ! result ) { // this appears to be handling for opaque type declarations @@ -188,7 +191,7 @@ } - void CommonType::visit( VoidType * ) {} - - void CommonType::visit( BasicType *basicType ) { + void CommonType::postvisit( VoidType * ) {} + + void CommonType::postvisit( BasicType *basicType ) { if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) { BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ]; @@ -219,5 +222,5 @@ } - void CommonType::visit( PointerType *pointerType ) { + void CommonType::postvisit( PointerType *pointerType ) { if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) { // std::cerr << "commonType: two pointers: " << pointerType << " / " << otherPointer << std::endl; @@ -254,7 +257,7 @@ } - void CommonType::visit( ArrayType * ) {} - - void CommonType::visit( ReferenceType *refType ) { + void CommonType::postvisit( ArrayType * ) {} + + void CommonType::postvisit( ReferenceType *refType ) { if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) { // std::cerr << "commonType: both references: " << refType << " / " << otherRef << std::endl; @@ -291,21 +294,19 @@ } - void CommonType::visit( FunctionType * ) {} - void CommonType::visit( StructInstType * ) {} - void CommonType::visit( UnionInstType * ) {} - - void CommonType::visit( EnumInstType *enumInstType ) { + void CommonType::postvisit( FunctionType * ) {} + void CommonType::postvisit( StructInstType * ) {} + void CommonType::postvisit( UnionInstType * ) {} + + void CommonType::postvisit( EnumInstType *enumInstType ) { if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) { // reuse BasicType, EnumInstType code by swapping type2 with enumInstType - ValueGuard< Type * > temp( type2 ); - type2 = enumInstType; - temp.old->accept( *this ); - } // if - } - - void CommonType::visit( TraitInstType * ) { - } - - void CommonType::visit( TypeInstType *inst ) { + result = commonType( type2, enumInstType, widenSecond, widenFirst, indexer, env, openVars ); + } // if + } + + void CommonType::postvisit( TraitInstType * ) { + } + + void CommonType::postvisit( TypeInstType *inst ) { if ( widenFirst ) { NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ); @@ -329,8 +330,8 @@ } - void CommonType::visit( TupleType * ) {} - void CommonType::visit( VarArgsType * ) {} - - void CommonType::visit( ZeroType *zeroType ) { + void CommonType::postvisit( TupleType * ) {} + void CommonType::postvisit( VarArgsType * ) {} + + void CommonType::postvisit( ZeroType *zeroType ) { if ( widenFirst ) { if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) { @@ -346,5 +347,5 @@ } - void CommonType::visit( OneType *oneType ) { + void CommonType::postvisit( OneType *oneType ) { if ( widenFirst ) { if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) { Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/ConversionCost.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -44,6 +44,6 @@ EqvClass eqvClass; NamedTypeDecl *namedType; - PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); ) - if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) { + PRINT( std::cerr << "type inst " << destAsTypeInst->name; ) + if ( env.lookup( destAsTypeInst->name, eqvClass ) ) { if ( eqvClass.type ) { return conversionCost( src, eqvClass.type, indexer, env ); @@ -51,11 +51,11 @@ return Cost::infinity; } - } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) { + } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) { 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::safe; + if ( type->base ) { + return conversionCost( src, type->base, indexer, env ) + Cost::safe; } // if } // if @@ -77,14 +77,14 @@ } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) { PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; ) - return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer &){ + return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){ return ptrsAssignable( t1, t2, env ); }); } else { - ConversionCost converter( dest, indexer, env ); + PassVisitor converter( dest, indexer, env, conversionCost ); src->accept( converter ); - if ( converter.get_cost() == Cost::infinity ) { + if ( converter.pass.get_cost() == Cost::infinity ) { return Cost::infinity; } else { - return converter.get_cost() + Cost::zero; + return converter.pass.get_cost() + Cost::zero; } // if } // if @@ -95,10 +95,10 @@ if ( diff > 0 ) { // TODO: document this - Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func ); + Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->base, dest, diff-1, indexer, env, func ); cost.incReference(); return cost; } else if ( diff < -1 ) { // TODO: document this - Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func ); + Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->base, diff+1, indexer, env, func ); cost.incReference(); return cost; @@ -108,7 +108,7 @@ if ( srcAsRef && destAsRef ) { // pointer-like conversions between references PRINT( std::cerr << "converting between references" << std::endl; ) - Type::Qualifiers tq1 = srcAsRef->get_base()->get_qualifiers(); - Type::Qualifiers tq2 = destAsRef->get_base()->get_qualifiers(); - if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) { + Type::Qualifiers tq1 = srcAsRef->base->get_qualifiers(); + Type::Qualifiers tq2 = destAsRef->base->get_qualifiers(); + if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->base, destAsRef->base, indexer, env ) ) { PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; ) if ( tq1 == tq2 ) { @@ -120,5 +120,5 @@ } } else { // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right? - int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer ); + int assignResult = func( srcAsRef->base, destAsRef->base, indexer, env ); PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; ) if ( assignResult > 0 ) { @@ -130,7 +130,7 @@ } else { PRINT( std::cerr << "reference to rvalue conversion" << std::endl; ) - ConversionCost converter( dest, indexer, env ); + PassVisitor converter( dest, indexer, env, conversionCost ); src->accept( converter ); - return converter.get_cost(); + return converter.pass.get_cost(); } // if } else { @@ -138,5 +138,5 @@ assert( diff == -1 && destAsRef ); PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; ) - if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) { + if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) { PRINT( std::cerr << "converting compatible base type" << std::endl; ) if ( src->get_lvalue() ) { @@ -146,12 +146,12 @@ ) // lvalue-to-reference conversion: cv lvalue T => cv T & - if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) { + if ( src->get_qualifiers() == destAsRef->base->get_qualifiers() ) { return Cost::reference; // cost needs to be non-zero to add cast - } if ( src->get_qualifiers() < destAsRef->get_base()->get_qualifiers() ) { + } if ( src->get_qualifiers() < destAsRef->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() ) { + } else if ( destAsRef->base->get_const() ) { PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; ) // rvalue-to-const-reference conversion: T => const T & @@ -173,6 +173,6 @@ } - ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) - : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ) { + ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ) + : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) { } @@ -257,9 +257,9 @@ }; - void ConversionCost::visit( VoidType * ) { + void ConversionCost::postvisit( VoidType * ) { cost = Cost::infinity; } - void ConversionCost::visit(BasicType *basicType) { + void ConversionCost::postvisit(BasicType *basicType) { if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) { int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ]; @@ -278,10 +278,10 @@ } - void ConversionCost::visit( PointerType * pointerType ) { + void ConversionCost::postvisit( PointerType * pointerType ) { if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) { PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; ) - 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 ) ) { + Type::Qualifiers tq1 = pointerType->base->get_qualifiers(); + Type::Qualifiers tq2 = destAsPtr->base->get_qualifiers(); + if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) { PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; ) if ( tq1 == tq2 ) { @@ -312,7 +312,7 @@ } - void ConversionCost::visit( ArrayType * ) {} - - void ConversionCost::visit( ReferenceType * refType ) { + void ConversionCost::postvisit( ArrayType * ) {} + + void ConversionCost::postvisit( ReferenceType * refType ) { // Note: dest can never be a reference, since it would have been caught in an earlier check assert( ! dynamic_cast< ReferenceType * >( dest ) ); @@ -320,5 +320,5 @@ // recursively compute conversion cost from T1 to T2. // cv can be safely dropped because of 'implicit dereference' behavior. - refType->base->accept( *this ); + cost = costFunc( refType->base, dest, indexer, env ); if ( refType->base->get_qualifiers() == dest->get_qualifiers() ) { cost.incReference(); // prefer exact qualifiers @@ -331,7 +331,7 @@ } - void ConversionCost::visit( FunctionType * ) {} - - void ConversionCost::visit( StructInstType * inst ) { + void ConversionCost::postvisit( FunctionType * ) {} + + void ConversionCost::postvisit( StructInstType * inst ) { if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) { if ( inst->name == destAsInst->name ) { @@ -341,5 +341,5 @@ } - void ConversionCost::visit( UnionInstType * inst ) { + void ConversionCost::postvisit( UnionInstType * inst ) { if ( UnionInstType *destAsInst = dynamic_cast< UnionInstType* >( dest ) ) { if ( inst->name == destAsInst->name ) { @@ -349,8 +349,8 @@ } - void ConversionCost::visit( EnumInstType * ) { + void ConversionCost::postvisit( EnumInstType * ) { static Type::Qualifiers q; static BasicType integer( q, BasicType::SignedInt ); - integer.accept( *this ); // safe if dest >= int + cost = costFunc( &integer, dest, indexer, env ); // safe if dest >= int if ( cost < Cost::unsafe ) { cost.incSafe(); @@ -358,32 +358,32 @@ } - void ConversionCost::visit( TraitInstType * ) {} - - void ConversionCost::visit( TypeInstType *inst ) { + void ConversionCost::postvisit( TraitInstType * ) {} + + void ConversionCost::postvisit( TypeInstType *inst ) { EqvClass eqvClass; NamedTypeDecl *namedType; - if ( env.lookup( inst->get_name(), eqvClass ) ) { - cost = conversionCost( eqvClass.type, dest, indexer, env ); + if ( env.lookup( inst->name, eqvClass ) ) { + cost = costFunc( eqvClass.type, dest, indexer, env ); } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) { - if ( inst->get_name() == destAsInst->get_name() ) { + if ( inst->name == destAsInst->name ) { cost = Cost::zero; } - } else if ( ( namedType = indexer.lookupType( inst->get_name() ) ) ) { + } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) { TypeDecl *type = dynamic_cast< TypeDecl* >( namedType ); // all typedefs should be gone by this point assert( type ); - if ( type->get_base() ) { - cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe; - } // if - } // if - } - - void ConversionCost::visit( TupleType * tupleType ) { + if ( type->base ) { + cost = costFunc( type->base, dest, indexer, env ) + Cost::safe; + } // if + } // if + } + + void ConversionCost::postvisit( TupleType * tupleType ) { Cost c = Cost::zero; if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) { - std::list< Type * >::const_iterator srcIt = tupleType->get_types().begin(); - std::list< Type * >::const_iterator destIt = destAsTuple->get_types().begin(); - while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) { - Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env ); + std::list< Type * >::const_iterator srcIt = tupleType->types.begin(); + std::list< Type * >::const_iterator destIt = destAsTuple->types.begin(); + while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) { + Cost newCost = costFunc( *srcIt++, *destIt++, indexer, env ); if ( newCost == Cost::infinity ) { return; @@ -391,5 +391,5 @@ c += newCost; } // while - if ( destIt != destAsTuple->get_types().end() ) { + if ( destIt != destAsTuple->types.end() ) { cost = Cost::infinity; } else { @@ -399,5 +399,5 @@ } - void ConversionCost::visit( VarArgsType * ) { + void ConversionCost::postvisit( VarArgsType * ) { if ( dynamic_cast< VarArgsType* >( dest ) ) { cost = Cost::zero; @@ -405,5 +405,5 @@ } - void ConversionCost::visit( ZeroType * ) { + void ConversionCost::postvisit( ZeroType * ) { if ( dynamic_cast< ZeroType * >( dest ) ) { cost = Cost::zero; @@ -422,5 +422,5 @@ } - void ConversionCost::visit( OneType * ) { + void ConversionCost::postvisit( OneType * ) { if ( dynamic_cast< OneType * >( dest ) ) { cost = Cost::zero; Index: src/ResolvExpr/ConversionCost.h =================================================================== --- src/ResolvExpr/ConversionCost.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/ConversionCost.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -19,4 +19,6 @@ #include "Cost.h" // for Cost + +#include "Common/PassVisitor.h" #include "SynTree/Visitor.h" // for Visitor #include "SynTree/SynTree.h" // for Visitor Nodes @@ -29,25 +31,28 @@ class TypeEnvironment; - class ConversionCost : public Visitor { + typedef std::function CostFunction; + struct ConversionCost : public WithShortCircuiting { public: - ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ); + ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction ); Cost get_cost() const { return cost; } - virtual void visit(VoidType *voidType); - virtual void visit(BasicType *basicType); - 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); - virtual void visit(UnionInstType *aggregateUseType); - virtual void visit(EnumInstType *aggregateUseType); - virtual void visit(TraitInstType *aggregateUseType); - virtual void visit(TypeInstType *aggregateUseType); - virtual void visit(TupleType *tupleType); - virtual void visit(VarArgsType *varArgsType); - virtual void visit(ZeroType *zeroType); - virtual void visit(OneType *oneType); + void previsit( BaseSyntaxNode * ) { visit_children = false; } + + void postvisit( VoidType * voidType ); + void postvisit( BasicType * basicType ); + void postvisit( PointerType * pointerType ); + void postvisit( ArrayType * arrayType ); + void postvisit( ReferenceType * refType ); + void postvisit( FunctionType * functionType ); + void postvisit( StructInstType * aggregateUseType ); + void postvisit( UnionInstType * aggregateUseType ); + void postvisit( EnumInstType * aggregateUseType ); + void postvisit( TraitInstType * aggregateUseType ); + void postvisit( TypeInstType * aggregateUseType ); + void postvisit( TupleType * tupleType ); + void postvisit( VarArgsType * varArgsType ); + void postvisit( ZeroType * zeroType ); + void postvisit( OneType * oneType ); protected: Type *dest; @@ -55,7 +60,8 @@ Cost cost; const TypeEnvironment &env; + CostFunction costFunc; }; - typedef std::function PtrsFunction; + typedef std::function PtrsFunction; Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ); } // namespace ResolvExpr Index: src/ResolvExpr/CurrentObject.cc =================================================================== --- src/ResolvExpr/CurrentObject.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/CurrentObject.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -62,14 +62,30 @@ virtual ~MemberIterator() {} + /// walks the current object using the given designators as a guide virtual void setPosition( std::list< Expression * > & designators ) = 0; + + /// retrieve the list of possible Type/Designaton pairs for the current position in the currect object virtual std::list operator*() const = 0; + + /// true if the iterator is not currently at the end virtual operator bool() const = 0; + + /// moves the iterator by one member in the current object virtual MemberIterator & bigStep() = 0; + + /// moves the iterator by one member in the current subobject virtual MemberIterator & smallStep() = 0; + + /// the type of the current object virtual Type * getType() = 0; + + /// the type of the current subobject virtual Type * getNext() = 0; + /// printing for debug virtual void print( std::ostream & out, Indenter indent ) const = 0; + /// helper for operator*; aggregates must add designator to each init alternative, but + /// adding designators in operator* creates duplicates. virtual std::list first() const = 0; // should be protected }; @@ -354,6 +370,5 @@ } } - // if ( curMember == std::next( decl->get_members().begin(), 1 ) ) { // xxx - this never triggers because curMember is incremented immediately on construction - if ( atbegin ) { // xxx - this never triggers because curMember is incremented immediately on construction + if ( atbegin ) { // xxx - what about case of empty struct?? // only add self if at the very beginning of the structure @@ -389,5 +404,4 @@ return *this; } - virtual std::list first() const { return std::list{}; } }; @@ -443,5 +457,5 @@ return new UnionIterator( uit ); } else { - assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype" ); + assertf( dynamic_cast< EnumInstType * >( type ) || dynamic_cast< TypeInstType * >( type ), "Encountered unhandled ReferenceToType in createMemberIterator: %s", toString( type ).c_str() ); return new SimpleIterator( type ); } Index: src/ResolvExpr/PtrsAssignable.cc =================================================================== --- src/ResolvExpr/PtrsAssignable.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/PtrsAssignable.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -14,4 +14,5 @@ // +#include "Common/PassVisitor.h" #include "ResolvExpr/TypeEnvironment.h" // for EqvClass, TypeEnvironment #include "SynTree/Type.h" // for TypeInstType, Type, BasicType @@ -20,24 +21,25 @@ namespace ResolvExpr { - class PtrsAssignable : public Visitor { - public: + struct PtrsAssignable : public WithShortCircuiting { PtrsAssignable( Type *dest, const TypeEnvironment &env ); int get_result() const { return result; } - virtual void visit( VoidType *voidType ); - virtual void visit( BasicType *basicType ); - virtual void visit( PointerType *pointerType ); - virtual void visit( ArrayType *arrayType ); - virtual void visit( FunctionType *functionType ); - virtual void visit( StructInstType *inst ); - virtual void visit( UnionInstType *inst ); - virtual void visit( EnumInstType *inst ); - virtual void visit( TraitInstType *inst ); - virtual void visit( TypeInstType *inst ); - virtual void visit( TupleType *tupleType ); - virtual void visit( VarArgsType *varArgsType ); - virtual void visit( ZeroType *zeroType ); - virtual void visit( OneType *oneType ); + void previsit( Type * ) { visit_children = false; } + + void postvisit( VoidType * voidType ); + void postvisit( BasicType * basicType ); + void postvisit( PointerType * pointerType ); + void postvisit( ArrayType * arrayType ); + void postvisit( FunctionType * functionType ); + void postvisit( StructInstType * inst ); + void postvisit( UnionInstType * inst ); + void postvisit( EnumInstType * inst ); + void postvisit( TraitInstType * inst ); + void postvisit( TypeInstType * inst ); + void postvisit( TupleType * tupleType ); + void postvisit( VarArgsType * varArgsType ); + void postvisit( ZeroType * zeroType ); + void postvisit( OneType * oneType ); private: Type *dest; @@ -59,7 +61,7 @@ return -1; } else { - PtrsAssignable ptrs( dest, env ); + PassVisitor ptrs( dest, env ); src->accept( ptrs ); - return ptrs.get_result(); + return ptrs.pass.get_result(); } // if } @@ -67,18 +69,18 @@ PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {} - void PtrsAssignable::visit( VoidType * ) { + void PtrsAssignable::postvisit( VoidType * ) { // T * = void * is disallowed - this is a change from C, where any // void * can be assigned or passed to a non-void pointer without a cast. } - void PtrsAssignable::visit( __attribute__((unused)) BasicType *basicType ) {} - void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {} - void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {} - void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {} + void PtrsAssignable::postvisit( __attribute__((unused)) BasicType *basicType ) {} + void PtrsAssignable::postvisit( __attribute__((unused)) PointerType *pointerType ) {} + void PtrsAssignable::postvisit( __attribute__((unused)) ArrayType *arrayType ) {} + void PtrsAssignable::postvisit( __attribute__((unused)) FunctionType *functionType ) {} - void PtrsAssignable::visit( __attribute__((unused)) StructInstType *inst ) {} - void PtrsAssignable::visit( __attribute__((unused)) UnionInstType *inst ) {} + void PtrsAssignable::postvisit( __attribute__((unused)) StructInstType *inst ) {} + void PtrsAssignable::postvisit( __attribute__((unused)) UnionInstType *inst ) {} - void PtrsAssignable::visit( EnumInstType * ) { + void PtrsAssignable::postvisit( EnumInstType * ) { if ( dynamic_cast< BasicType* >( dest ) ) { // int * = E *, etc. is safe. This isn't technically correct, as each @@ -91,6 +93,6 @@ } - void PtrsAssignable::visit( __attribute__((unused)) TraitInstType *inst ) {} - void PtrsAssignable::visit( TypeInstType *inst ) { + void PtrsAssignable::postvisit( __attribute__((unused)) TraitInstType *inst ) {} + void PtrsAssignable::postvisit( TypeInstType *inst ) { EqvClass eqvClass; if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) { @@ -100,8 +102,8 @@ } - void PtrsAssignable::visit( __attribute__((unused)) TupleType *tupleType ) {} - void PtrsAssignable::visit( __attribute__((unused)) VarArgsType *varArgsType ) {} - void PtrsAssignable::visit( __attribute__((unused)) ZeroType *zeroType ) {} - void PtrsAssignable::visit( __attribute__((unused)) OneType *oneType ) {} + void PtrsAssignable::postvisit( __attribute__((unused)) TupleType *tupleType ) {} + void PtrsAssignable::postvisit( __attribute__((unused)) VarArgsType *varArgsType ) {} + void PtrsAssignable::postvisit( __attribute__((unused)) ZeroType *zeroType ) {} + void PtrsAssignable::postvisit( __attribute__((unused)) OneType *oneType ) {} } // namespace ResolvExpr Index: src/ResolvExpr/PtrsCastable.cc =================================================================== --- src/ResolvExpr/PtrsCastable.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/PtrsCastable.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -14,4 +14,5 @@ // +#include "Common/PassVisitor.h" #include "ResolvExpr/TypeEnvironment.h" // for EqvClass, TypeEnvironment #include "SymTab/Indexer.h" // for Indexer @@ -21,7 +22,6 @@ #include "typeops.h" // for ptrsAssignable - namespace ResolvExpr { - class PtrsCastable : public Visitor { + struct PtrsCastable : public WithShortCircuiting { public: PtrsCastable( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ); @@ -29,18 +29,20 @@ int get_result() const { return result; } - virtual void visit(VoidType *voidType); - virtual void visit(BasicType *basicType); - virtual void visit(PointerType *pointerType); - virtual void visit(ArrayType *arrayType); - virtual void visit(FunctionType *functionType); - virtual void visit(StructInstType *inst); - virtual void visit(UnionInstType *inst); - virtual void visit(EnumInstType *inst); - virtual void visit(TraitInstType *inst); - virtual void visit(TypeInstType *inst); - virtual void visit(TupleType *tupleType); - virtual void visit(VarArgsType *varArgsType); - virtual void visit(ZeroType *zeroType); - virtual void visit(OneType *oneType); + void previsit( Type * ) { visit_children = false; } + + void postvisit( VoidType * voidType ); + void postvisit( BasicType * basicType ); + void postvisit( PointerType * pointerType ); + void postvisit( ArrayType * arrayType ); + void postvisit( FunctionType * functionType ); + void postvisit( StructInstType * inst ); + void postvisit( UnionInstType * inst ); + void postvisit( EnumInstType * inst ); + void postvisit( TraitInstType * inst ); + void postvisit( TypeInstType * inst ); + void postvisit( TupleType * tupleType ); + void postvisit( VarArgsType * varArgsType ); + void postvisit( ZeroType * zeroType ); + void postvisit( OneType * oneType ); private: Type *dest; @@ -79,4 +81,5 @@ EqvClass eqvClass; if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) { + // xxx - should this be ptrsCastable? return ptrsAssignable( src, eqvClass.type, env ); } // if @@ -85,7 +88,7 @@ return objectCast( src, env, indexer ); } else { - PtrsCastable ptrs( dest, env, indexer ); + PassVisitor ptrs( dest, env, indexer ); src->accept( ptrs ); - return ptrs.get_result(); + return ptrs.pass.get_result(); } // if } @@ -95,34 +98,34 @@ } - void PtrsCastable::visit( VoidType * ) { + void PtrsCastable::postvisit( VoidType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( BasicType * ) { + void PtrsCastable::postvisit( BasicType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( PointerType * ) { + void PtrsCastable::postvisit( PointerType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( ArrayType * ) { + void PtrsCastable::postvisit( ArrayType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( FunctionType * ) { + void PtrsCastable::postvisit( FunctionType * ) { // result = -1; result = functionCast( dest, env, indexer ); } - void PtrsCastable::visit( StructInstType * ) { + void PtrsCastable::postvisit( StructInstType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( UnionInstType * ) { + void PtrsCastable::postvisit( UnionInstType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( EnumInstType * ) { + void PtrsCastable::postvisit( EnumInstType * ) { if ( dynamic_cast< EnumInstType* >( dest ) ) { result = 1; @@ -138,24 +141,24 @@ } - void PtrsCastable::visit( TraitInstType * ) {} + void PtrsCastable::postvisit( TraitInstType * ) {} - void PtrsCastable::visit(TypeInstType *inst) { + void PtrsCastable::postvisit(TypeInstType *inst) { //result = objectCast( inst, env, indexer ) > 0 && objectCast( dest, env, indexer ) > 0 ? 1 : -1; result = objectCast( inst, env, indexer ) == objectCast( dest, env, indexer ) ? 1 : -1; } - void PtrsCastable::visit( TupleType * ) { + void PtrsCastable::postvisit( TupleType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( VarArgsType * ) { + void PtrsCastable::postvisit( VarArgsType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( ZeroType * ) { + void PtrsCastable::postvisit( ZeroType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( OneType * ) { + void PtrsCastable::postvisit( OneType * ) { result = objectCast( dest, env, indexer ); } Index: src/ResolvExpr/RenameVars.cc =================================================================== --- src/ResolvExpr/RenameVars.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/RenameVars.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -19,4 +19,5 @@ #include // for pair +#include "Common/PassVisitor.h" #include "Common/SemanticError.h" // for SemanticError #include "RenameVars.h" @@ -27,126 +28,72 @@ namespace ResolvExpr { - RenameVars global_renamer; + namespace { + struct RenameVars { + RenameVars(); + void reset(); - RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) { - mapStack.push_front( std::map< std::string, std::string >() ); + void previsit( TypeInstType * instType ); + void previsit( Type * ); + void postvisit( Type * ); + + private: + int level, resetCount; + std::list< std::map< std::string, std::string > > mapStack; + }; + + PassVisitor global_renamer; + } // namespace + + void renameTyVars( Type * t ) { + t->accept( global_renamer ); } - void RenameVars::reset() { - level = 0; - resetCount++; + void resetTyVarRenaming() { + global_renamer.pass.reset(); } - void RenameVars::visit( VoidType *voidType ) { - typeBefore( voidType ); - typeAfter( voidType ); - } + namespace { + RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) { + mapStack.push_front( std::map< std::string, std::string >() ); + } - void RenameVars::visit( BasicType *basicType ) { - typeBefore( basicType ); - typeAfter( basicType ); - } + void RenameVars::reset() { + level = 0; + resetCount++; + } - void RenameVars::visit( PointerType *pointerType ) { - typeBefore( pointerType ); - maybeAccept( pointerType->get_base(), *this ); - typeAfter( pointerType ); - } + void RenameVars::previsit( TypeInstType * instType ) { + previsit( (Type *)instType ); + std::map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->name ); + if ( i != mapStack.front().end() ) { + instType->name = i->second; + } // if + } - void RenameVars::visit( ArrayType *arrayType ) { - typeBefore( arrayType ); - maybeAccept( arrayType->get_dimension(), *this ); - maybeAccept( arrayType->get_base(), *this ); - typeAfter( arrayType ); - } + void RenameVars::previsit( Type * type ) { + if ( ! type->forall.empty() ) { + // copies current name mapping into new mapping + mapStack.push_front( mapStack.front() ); + // renames all "forall" type names to `_${level}_${name}' + for ( auto td : type->forall ) { + std::ostringstream output; + output << "_" << resetCount << "_" << level << "_" << td->name; + std::string newname( output.str() ); + mapStack.front()[ td->get_name() ] = newname; + td->name = newname; + // ditto for assertion names, the next level in + level++; + // acceptAll( td->assertions, *this ); + } // for + } // if + } - void RenameVars::visit( FunctionType *functionType ) { - typeBefore( functionType ); - acceptAll( functionType->get_returnVals(), *this ); - acceptAll( functionType->get_parameters(), *this ); - typeAfter( functionType ); - } - - void RenameVars::visit( StructInstType *aggregateUseType ) { - typeBefore( aggregateUseType ); - acceptAll( aggregateUseType->get_parameters(), *this ); - typeAfter( aggregateUseType ); - } - - void RenameVars::visit( UnionInstType *aggregateUseType ) { - typeBefore( aggregateUseType ); - acceptAll( aggregateUseType->get_parameters(), *this ); - typeAfter( aggregateUseType ); - } - - void RenameVars::visit( EnumInstType *aggregateUseType ) { - typeBefore( aggregateUseType ); - acceptAll( aggregateUseType->get_parameters(), *this ); - typeAfter( aggregateUseType ); - } - - void RenameVars::visit( TraitInstType *aggregateUseType ) { - typeBefore( aggregateUseType ); - acceptAll( aggregateUseType->get_parameters(), *this ); - typeAfter( aggregateUseType ); - } - - void RenameVars::visit( TypeInstType *instType ) { - typeBefore( instType ); - std::map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->get_name() ); - if ( i != mapStack.front().end() ) { - instType->set_name( i->second ); - } else { - } // if - acceptAll( instType->get_parameters(), *this ); - typeAfter( instType ); - } - - void RenameVars::visit( TupleType *tupleType ) { - typeBefore( tupleType ); - acceptAll( tupleType->get_types(), *this ); - typeAfter( tupleType ); - } - - void RenameVars::visit( VarArgsType *varArgsType ) { - typeBefore( varArgsType ); - typeAfter( varArgsType ); - } - - void RenameVars::visit( ZeroType *zeroType ) { - typeBefore( zeroType ); - typeAfter( zeroType ); - } - - void RenameVars::visit( OneType *oneType ) { - typeBefore( oneType ); - typeAfter( oneType ); - } - - void RenameVars::typeBefore( Type *type ) { - if ( ! type->get_forall().empty() ) { - // copies current name mapping into new mapping - mapStack.push_front( mapStack.front() ); - // renames all "forall" type names to `_${level}_${name}' - for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) { - std::ostringstream output; - output << "_" << resetCount << "_" << level << "_" << (*i)->get_name(); - std::string newname( output.str() ); - mapStack.front()[ (*i)->get_name() ] = newname; - (*i)->set_name( newname ); - // ditto for assertion names, the next level in - level++; - acceptAll( (*i)->get_assertions(), *this ); - } // for - } // if - } - - void RenameVars::typeAfter( Type *type ) { - // clears name mapping added by typeBefore() - if ( ! type->get_forall().empty() ) { - mapStack.pop_front(); - } // if - } - + void RenameVars::postvisit( Type * type ) { + // clears name mapping added by typeBefore() + if ( ! type->forall.empty() ) { + mapStack.pop_front(); + } // if + } + } // namespace } // namespace ResolvExpr Index: src/ResolvExpr/RenameVars.h =================================================================== --- src/ResolvExpr/RenameVars.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/RenameVars.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -24,33 +24,9 @@ namespace ResolvExpr { + /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID + void renameTyVars( Type * ); - /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID - class RenameVars : public Visitor { - public: - RenameVars(); - void reset(); - private: - virtual void visit( VoidType *basicType ); - virtual void visit( BasicType *basicType ); - virtual void visit( PointerType *pointerType ); - virtual void visit( ArrayType *arrayType ); - virtual void visit( FunctionType *functionType ); - virtual void visit( StructInstType *aggregateUseType ); - virtual void visit( UnionInstType *aggregateUseType ); - virtual void visit( EnumInstType *aggregateUseType ); - virtual void visit( TraitInstType *aggregateUseType ); - virtual void visit( TypeInstType *aggregateUseType ); - virtual void visit( TupleType *tupleType ); - virtual void visit( VarArgsType *varArgsType ); - virtual void visit( ZeroType *zeroType ); - virtual void visit( OneType *oneType ); - - void typeBefore( Type *type ); - void typeAfter( Type *type ); - int level, resetCount; - std::list< std::map< std::string, std::string > > mapStack; - }; - - extern RenameVars global_renamer; + /// resets internal state of renamer to avoid overflow + void resetTyVarRenaming(); } // namespace ResolvExpr Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/Resolver.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -132,5 +132,5 @@ void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) { - global_renamer.reset(); + resetTyVarRenaming(); TypeEnvironment env; Expression *newExpr = resolveInVoidContext( untyped, indexer, env ); @@ -155,5 +155,5 @@ } // if #endif - assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." ); + assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end: (%zd) %s", finder.get_alternatives().size(), toString( untyped ).c_str() ); Alternative &choice = finder.get_alternatives().front(); Expression *newExpr = choice.expr->clone(); @@ -171,4 +171,40 @@ namespace { + /// resolve `untyped` to the expression whose type satisfies `pred` with the lowest cost; kindStr is used for providing better error messages + template + void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, Pred pred) { + TypeEnvironment env; + AlternativeFinder finder( indexer, env ); + finder.findWithAdjustment( untyped ); + + AltList candidates; + for ( Alternative & alt : finder.get_alternatives() ) { + if ( pred( alt.expr->result ) ) { + candidates.push_back( std::move( alt ) ); + } + } + + // choose the lowest cost expression among the candidates + AltList winners; + findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) ); + if ( winners.size() == 0 ) { + throw SemanticError( "No reasonable alternatives for " + kindStr + " expression: ", untyped ); + } else if ( winners.size() != 1 ) { + std::ostringstream stream; + stream << "Cannot choose between " << winners.size() << " alternatives for " + kindStr + " expression\n"; + untyped->print( stream ); + stream << "Alternatives are:\n"; + printAlts( winners, stream, 1 ); + throw SemanticError( stream.str() ); + } + + // there is one unambiguous interpretation - move the expression into the with statement + Alternative & alt = winners.front(); + finishExpr( alt.expr, alt.env, untyped->env ); + delete untyped; + untyped = alt.expr; + alt.expr = nullptr; + } + bool isIntegralType( Type *type ) { if ( dynamic_cast< EnumInstType * >( type ) ) { @@ -184,37 +220,6 @@ void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) { - TypeEnvironment env; - AlternativeFinder finder( indexer, env ); - finder.find( untyped ); -#if 0 - if ( finder.get_alternatives().size() != 1 ) { - std::cout << "untyped expr is "; - untyped->print( std::cout ); - std::cout << std::endl << "alternatives are:"; - for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { - i->print( std::cout ); - } // for - } // if -#endif - Expression *newExpr = 0; - const TypeEnvironment *newEnv = 0; - for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { - if ( i->expr->get_result()->size() == 1 && isIntegralType( i->expr->get_result() ) ) { - if ( newExpr ) { - throw SemanticError( "Too many interpretations for case control expression", untyped ); - } else { - newExpr = i->expr->clone(); - newEnv = &i->env; - } // if - } // if - } // for - if ( ! newExpr ) { - throw SemanticError( "No interpretations for case control expression", untyped ); - } // if - finishExpr( newExpr, *newEnv, untyped->env ); - delete untyped; - untyped = newExpr; - } - + findKindExpression( untyped, indexer, "condition", isIntegralType ); + } } @@ -311,14 +316,14 @@ void Resolver::previsit( IfStmt *ifStmt ) { - findSingleExpression( ifStmt->condition, indexer ); + findIntegralExpression( ifStmt->condition, indexer ); } void Resolver::previsit( WhileStmt *whileStmt ) { - findSingleExpression( whileStmt->condition, indexer ); + findIntegralExpression( whileStmt->condition, indexer ); } void Resolver::previsit( ForStmt *forStmt ) { if ( forStmt->condition ) { - findSingleExpression( forStmt->condition, indexer ); + findIntegralExpression( forStmt->condition, indexer ); } // if @@ -579,38 +584,9 @@ } + void Resolver::previsit( WithStmt * withStmt ) { for ( Expression *& expr : withStmt->exprs ) { - TypeEnvironment env; - AlternativeFinder finder( indexer, env ); - finder.findWithAdjustment( expr ); - // only struct- and union-typed expressions are viable candidates - AltList candidates; - for ( Alternative & alt : finder.get_alternatives() ) { - if ( isStructOrUnion( alt.expr->result ) ) { - candidates.push_back( std::move( alt ) ); - } - } - - // choose the lowest cost expression among the candidates - AltList winners; - findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) ); - if ( winners.size() == 0 ) { - throw SemanticError( "No reasonable alternatives for with statement expression: ", expr ); - } else if ( winners.size() != 1 ) { - std::ostringstream stream; - stream << "Cannot choose between " << winners.size() << " alternatives for with statement expression\n"; - expr->print( stream ); - stream << "Alternatives are:\n"; - printAlts( winners, stream, 1 ); - throw SemanticError( stream.str() ); - } - - // there is one unambiguous interpretation - move the expression into the with statement - Alternative & alt = winners.front(); - finishExpr( alt.expr, alt.env, expr->env ); - delete expr; - expr = alt.expr; - alt.expr = nullptr; + findKindExpression( expr, indexer, "with statement", isStructOrUnion ); // if with expression might be impure, create a temporary so that it is evaluated once Index: src/ResolvExpr/TypeMap.h =================================================================== --- src/ResolvExpr/TypeMap.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,209 +1,0 @@ -// -// 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. -// -// ScopedMap.h -- -// -// Author : Aaron B. Moss -// Created On : Fri Feb 19 13:55:00 2016 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:37:19 2017 -// Update Count : 2 -// - -#pragma once - -#include -#include -#include -#include - -#include "SynTree/Type.h" -#include "SynTree/Visitor.h" - -namespace ResolvExpr { - - /// A map from types to some value; lookup is done by structural decomposition on types. - /// The TypeMap stores its values by reference, so stored objects should be kept alive by the caller. - /// The scoping mechanism essentially by keeping a list of changes to roll back, then rolling them back - /// WARNING: This map is only incompletely and approximately consistent with the resolution rules in Unify.cc; - /// it has potential, if extended, to form the basis of a resolver that is more performant than the current - /// linear-search-by-unification approach, but is only currently used for finding assignment operators in GenPoly::box. - template< typename Value > - class TypeMap { - /// Map of names to types - typedef typename std::map< std::string, Value* > ValueMap; - typedef typename ValueMap::iterator ValueMapIterator; - - Value *voidValue; ///< Value for void type - Value *basicValue[BasicType::NUMBER_OF_BASIC_TYPES]; ///< Values for basic types - Value *pointerValue; ///< Value for all pointer types - Value *voidPointerValue; ///< Value for void* types - Value *functionPointerValue; ///< Value for all function pointer types - ValueMap structValue; ///< Values for struct types, indexed by name - ValueMap unionValue; ///< Values for struct types, indexed by name - ValueMap enumValue; ///< Values for struct types, indexed by name - - /// Information needed to roll back one scope change - struct Rollback { - /// One scope of pointer rollbacks - typedef std::vector< std::pair< Value **, Value* > > PointerScope; - /// One scope of map rollbacks - typedef std::vector< std::pair< ValueMapIterator, Value* > > MapScope; - - PointerScope pointers; ///< Value pointers to roll back to their previous state - MapScope mapNodes; ///< Value map iterators to roll back to their previous state - - void addRollback( Value **loc, Value *old ) { - pointers.push_back( std::make_pair( loc, old ) ); - } - - void addRollback( ValueMapIterator loc, Value *old ) { - mapNodes.push_back( std::make_pair( loc, old ) ); - } - }; - - std::vector< Rollback > scopes; ///< Scope rollback information - - struct Lookup : public Visitor { - Lookup( TypeMap &typeMap ) : typeMap( typeMap ), found( 0 ), toInsert( 0 ) {} - - /// Inserts a new value into the map; returns the old value (if set, NULL otherwise). - /// key must be non-null. - Value *insert( Type *key, Value *val ) { - toInsert = val; - key->accept( *this ); - return found; - } - - /// Looks up a value in the map. - /// key must be non-null. - Value *find( Type *key ) { - //toInsert = 0; - key->accept( *this ); - return found; - } - - void findAndReplace( Value *&loc ) { - found = loc; - if ( toInsert ) { - typeMap.scopes.back().addRollback( &loc, found ); - loc = toInsert; - } - } - - void findAndReplace( ValueMap &map, const std::string &name ) { - ValueMapIterator loc = map.find( name ); - if ( loc != map.end() ) { - found = loc->second; - if ( toInsert ) { - typeMap.scopes.back().addRollback( loc, found ); - loc->second = toInsert; - } - } else if ( toInsert ) { - loc = map.insert( loc, std::make_pair( name, toInsert ) ); - typeMap.scopes.back().addRollback( loc, found ); - } - } - - virtual void visit( __attribute__((unused)) VoidType *voidType ) { - findAndReplace( typeMap.voidValue ); - } - - virtual void visit( BasicType *basicType ) { - findAndReplace( typeMap.basicValue[basicType->get_kind()] ); - } - - virtual void visit( PointerType *pointerType ) { - // NOTE This is one of the places where the apporoximation of the resolver is (deliberately) poor; - // A better version would likely not equate all pointer types to a match. - if ( dynamic_cast< FunctionType* >( pointerType->get_base() ) ) { - findAndReplace( typeMap.functionPointerValue ); - } else if ( dynamic_cast< VoidType* >( pointerType->get_base() ) ) { - findAndReplace( typeMap.voidPointerValue ); - } else { - findAndReplace( typeMap.pointerValue ); - } - } - - virtual void visit( ArrayType *arrayType ) { - if ( dynamic_cast< FunctionType* >( arrayType->get_base() ) ) { - findAndReplace( typeMap.functionPointerValue ); - } else { - findAndReplace( typeMap.pointerValue ); - } - } - - virtual void visit( __attribute__((unused)) FunctionType *functionType ) { - findAndReplace( typeMap.functionPointerValue ); - } - - virtual void visit( StructInstType *structType ) { - findAndReplace( typeMap.structValue, structType->get_name() ); - } - - virtual void visit( UnionInstType *unionType ) { - findAndReplace( typeMap.unionValue, unionType->get_name() ); - } - - virtual void visit( EnumInstType *enumType ) { - findAndReplace( typeMap.enumValue, enumType->get_name() ); - } - - TypeMap &typeMap; ///< map storage - Value *found; ///< Value found (NULL if none yet) - Value *toInsert; ///< Value to insert (NULL if a lookup) - }; // struct Lookup - friend struct Lookup; - - public: - /// Starts a new scope - void beginScope() { - Rollback scope; - scopes.push_back(scope); - } - - /// Ends a scope; rolls back any changes made during that scope - void endScope() { - Rollback &scope = scopes.back(); - /// Roll back pointer changes - for (unsigned i = 0; i < scope.pointers.size(); ++i) { - *scope.pointers[i].first = scope.pointers[i].second; - } - /// Roll back map changes - for (unsigned i = 0; i < scope.mapNodes.size(); ++i) { - scope.mapNodes[i].first->second = scope.mapNodes[i].second; - } - scopes.pop_back(); - } - - TypeMap() : voidValue( 0 ), pointerValue( 0 ), voidPointerValue( 0 ), functionPointerValue( 0 ), structValue(), unionValue(), enumValue(), scopes() { - beginScope(); - for (int i = 0; i < BasicType::NUMBER_OF_BASIC_TYPES; ++i) { basicValue[i] = 0; } - } - - /// Inserts a new value into the map; returns the old value (if set, NULL otherwise). - /// key, val must be non-null. - Value *insert( Type *key, Value *val ) { - Lookup searcher( *this ); - return searcher.insert( key, val ); - } - - /// Looks up a value in the map. - /// key must be non-null - Value *find( Type *key ) { - Lookup searcher( *this ); - return searcher.find( key ); - } - - }; // class TypeMap - -} // namespace ResolvExpr - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/ResolvExpr/Unify.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -44,26 +44,28 @@ namespace ResolvExpr { - class Unify : public Visitor { - public: + struct Unify : public WithShortCircuiting { Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ); bool get_result() const { return result; } + + void previsit( BaseSyntaxNode * ) { visit_children = false; } + + void postvisit( VoidType * voidType ); + void postvisit( BasicType * basicType ); + void postvisit( PointerType * pointerType ); + void postvisit( ArrayType * arrayType ); + void postvisit( ReferenceType * refType ); + void postvisit( FunctionType * functionType ); + void postvisit( StructInstType * aggregateUseType ); + void postvisit( UnionInstType * aggregateUseType ); + void postvisit( EnumInstType * aggregateUseType ); + void postvisit( TraitInstType * aggregateUseType ); + void postvisit( TypeInstType * aggregateUseType ); + void postvisit( TupleType * tupleType ); + void postvisit( VarArgsType * varArgsType ); + void postvisit( ZeroType * zeroType ); + void postvisit( OneType * oneType ); + private: - virtual void visit(VoidType *voidType); - virtual void visit(BasicType *basicType); - 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); - virtual void visit(UnionInstType *aggregateUseType); - virtual void visit(EnumInstType *aggregateUseType); - virtual void visit(TraitInstType *aggregateUseType); - virtual void visit(TypeInstType *aggregateUseType); - virtual void visit(TupleType *tupleType); - virtual void visit(VarArgsType *varArgsType); - virtual void visit(ZeroType *zeroType); - virtual void visit(OneType *oneType); - template< typename RefType > void handleRefType( RefType *inst, Type *other ); template< typename RefType > void handleGenericRefType( RefType *inst, Type *other ); @@ -325,7 +327,7 @@ result = bindVar( var2, type1, entry2->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer ); } else { - Unify comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer ); + PassVisitor comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer ); type1->accept( comparator ); - result = comparator.get_result(); + result = comparator.pass.get_result(); } // if #ifdef DEBUG @@ -404,9 +406,9 @@ } - void Unify::visit( __attribute__((unused)) VoidType *voidType) { + void Unify::postvisit( __attribute__((unused)) VoidType *voidType) { result = dynamic_cast< VoidType* >( type2 ); } - void Unify::visit(BasicType *basicType) { + void Unify::postvisit(BasicType *basicType) { if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) { result = basicType->get_kind() == otherBasic->get_kind(); @@ -436,5 +438,5 @@ } - void Unify::visit(PointerType *pointerType) { + void Unify::postvisit(PointerType *pointerType) { if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) { result = unifyExact( pointerType->get_base(), otherPointer->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); @@ -444,5 +446,5 @@ } - void Unify::visit(ReferenceType *refType) { + void Unify::postvisit(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 ); @@ -452,5 +454,5 @@ } - void Unify::visit(ArrayType *arrayType) { + void Unify::postvisit(ArrayType *arrayType) { ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 ); // to unify, array types must both be VLA or both not VLA @@ -567,5 +569,5 @@ } - void Unify::visit(FunctionType *functionType) { + void Unify::postvisit(FunctionType *functionType) { FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 ); if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) { @@ -669,21 +671,21 @@ } - void Unify::visit(StructInstType *structInst) { + void Unify::postvisit(StructInstType *structInst) { handleGenericRefType( structInst, type2 ); } - void Unify::visit(UnionInstType *unionInst) { + void Unify::postvisit(UnionInstType *unionInst) { handleGenericRefType( unionInst, type2 ); } - void Unify::visit(EnumInstType *enumInst) { + void Unify::postvisit(EnumInstType *enumInst) { handleRefType( enumInst, type2 ); } - void Unify::visit(TraitInstType *contextInst) { + void Unify::postvisit(TraitInstType *contextInst) { handleRefType( contextInst, type2 ); } - void Unify::visit(TypeInstType *typeInst) { + void Unify::postvisit(TypeInstType *typeInst) { assert( openVars.find( typeInst->get_name() ) == openVars.end() ); TypeInstType *otherInst = dynamic_cast< TypeInstType* >( type2 ); @@ -740,5 +742,5 @@ } - void Unify::visit(TupleType *tupleType) { + void Unify::postvisit(TupleType *tupleType) { if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) { std::unique_ptr flat1( tupleType->clone() ); @@ -757,13 +759,13 @@ } - void Unify::visit( __attribute__((unused)) VarArgsType *varArgsType ) { + void Unify::postvisit( __attribute__((unused)) VarArgsType *varArgsType ) { result = dynamic_cast< VarArgsType* >( type2 ); } - void Unify::visit( __attribute__((unused)) ZeroType *zeroType ) { + void Unify::postvisit( __attribute__((unused)) ZeroType *zeroType ) { result = dynamic_cast< ZeroType* >( type2 ); } - void Unify::visit( __attribute__((unused)) OneType *oneType ) { + void Unify::postvisit( __attribute__((unused)) OneType *oneType ) { result = dynamic_cast< OneType* >( type2 ); } Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/SymTab/Mangler.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -23,4 +23,5 @@ #include "CodeGen/OperatorTable.h" // for OperatorInfo, operatorLookup +#include "Common/PassVisitor.h" #include "Common/SemanticError.h" // for SemanticError #include "Common/utility.h" // for toString @@ -31,285 +32,340 @@ namespace SymTab { - std::string Mangler::mangleType( Type * ty ) { - Mangler mangler( false, true, true ); - maybeAccept( ty, mangler ); - return mangler.get_mangleName(); - } - - std::string Mangler::mangleConcrete( Type* ty ) { - Mangler mangler( false, false, false ); - maybeAccept( ty, mangler ); - return mangler.get_mangleName(); - } - - Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams ) - : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {} - - Mangler::Mangler( const Mangler &rhs ) : mangleName() { - varNums = rhs.varNums; - nextVarNum = rhs.nextVarNum; - isTopLevel = rhs.isTopLevel; - mangleOverridable = rhs.mangleOverridable; - typeMode = rhs.typeMode; - } - - void Mangler::mangleDecl( DeclarationWithType * declaration ) { - bool wasTopLevel = isTopLevel; - if ( isTopLevel ) { - varNums.clear(); - nextVarNum = 0; - isTopLevel = false; - } // if - mangleName << "__"; - CodeGen::OperatorInfo opInfo; - if ( operatorLookup( declaration->get_name(), opInfo ) ) { - mangleName << opInfo.outputName; - } else { - mangleName << declaration->get_name(); - } // if - mangleName << "__"; - maybeAccept( declaration->get_type(), *this ); - if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) { - // want to be able to override autogenerated and intrinsic routines, - // so they need a different name mangling - if ( declaration->get_linkage() == LinkageSpec::AutoGen ) { - mangleName << "autogen__"; - } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) { - mangleName << "intrinsic__"; - } else { - // if we add another kind of overridable function, this has to change - assert( false && "unknown overrideable linkage" ); - } // if + namespace Mangler { + namespace { + /// Mangles names to a unique C identifier + struct Mangler : public WithShortCircuiting, public WithVisitorRef { + Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams ); + Mangler( const Mangler & ); + + void previsit( BaseSyntaxNode * ) { visit_children = false; } + + void postvisit( ObjectDecl * declaration ); + void postvisit( FunctionDecl * declaration ); + void postvisit( TypeDecl * declaration ); + + void postvisit( VoidType * voidType ); + void postvisit( BasicType * basicType ); + void postvisit( PointerType * pointerType ); + void postvisit( ArrayType * arrayType ); + void postvisit( ReferenceType * refType ); + void postvisit( FunctionType * functionType ); + void postvisit( StructInstType * aggregateUseType ); + void postvisit( UnionInstType * aggregateUseType ); + void postvisit( EnumInstType * aggregateUseType ); + void postvisit( TypeInstType * aggregateUseType ); + void postvisit( TupleType * tupleType ); + void postvisit( VarArgsType * varArgsType ); + void postvisit( ZeroType * zeroType ); + void postvisit( OneType * oneType ); + + std::string get_mangleName() { return mangleName.str(); } + private: + std::ostringstream mangleName; ///< Mangled name being constructed + typedef std::map< std::string, std::pair< int, int > > VarMapType; + VarMapType varNums; ///< Map of type variables to indices + int nextVarNum; ///< Next type variable index + bool isTopLevel; ///< Is the Mangler at the top level + bool mangleOverridable; ///< Specially mangle overridable built-in methods + bool typeMode; ///< Produce a unique mangled name for a type + bool mangleGenericParams; ///< Include generic parameters in name mangling if true + + void mangleDecl( DeclarationWithType *declaration ); + void mangleRef( ReferenceToType *refType, std::string prefix ); + + void printQualifiers( Type *type ); + }; // Mangler + } // namespace + + std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) { + PassVisitor mangler( mangleOverridable, typeMode, mangleGenericParams ); + maybeAccept( decl, mangler ); + return mangler.pass.get_mangleName(); } - isTopLevel = wasTopLevel; - } - - void Mangler::visit( ObjectDecl * declaration ) { - mangleDecl( declaration ); - } - - void Mangler::visit( FunctionDecl * declaration ) { - mangleDecl( declaration ); - } - - void Mangler::visit( VoidType * voidType ) { - printQualifiers( voidType ); - mangleName << "v"; - } - - void Mangler::visit( BasicType * basicType ) { - static const char *btLetter[] = { - "b", // Bool - "c", // Char - "Sc", // SignedChar - "Uc", // UnsignedChar - "s", // ShortSignedInt - "Us", // ShortUnsignedInt - "i", // SignedInt - "Ui", // UnsignedInt - "l", // LongSignedInt - "Ul", // LongUnsignedInt - "q", // LongLongSignedInt - "Uq", // LongLongUnsignedInt - "f", // Float - "d", // Double - "r", // LongDouble - "Xf", // FloatComplex - "Xd", // DoubleComplex - "Xr", // LongDoubleComplex - "If", // FloatImaginary - "Id", // DoubleImaginary - "Ir", // LongDoubleImaginary - "w", // SignedInt128 - "Uw", // UnsignedInt128 - }; - - printQualifiers( basicType ); - mangleName << btLetter[ basicType->get_kind() ]; - } - - void Mangler::visit( PointerType * pointerType ) { - printQualifiers( pointerType ); - mangleName << "P"; - maybeAccept( pointerType->get_base(), *this ); - } - - void Mangler::visit( ArrayType * arrayType ) { - // TODO: encode dimension - printQualifiers( arrayType ); - mangleName << "A0"; - maybeAccept( arrayType->get_base(), *this ); - } - - void Mangler::visit( ReferenceType * refType ) { - printQualifiers( refType ); - mangleName << "R"; - maybeAccept( refType->get_base(), *this ); - } - - namespace { - inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) { - std::list< Type* > ret; - std::transform( decls.begin(), decls.end(), std::back_inserter( ret ), - std::mem_fun( &DeclarationWithType::get_type ) ); - return ret; + + std::string mangleType( Type * ty ) { + PassVisitor mangler( false, true, true ); + maybeAccept( ty, mangler ); + return mangler.pass.get_mangleName(); } - } - - void Mangler::visit( FunctionType * functionType ) { - printQualifiers( functionType ); - mangleName << "F"; - std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() ); - acceptAll( returnTypes, *this ); - mangleName << "_"; - std::list< Type* > paramTypes = getTypes( functionType->get_parameters() ); - acceptAll( paramTypes, *this ); - mangleName << "_"; - } - - void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) { - printQualifiers( refType ); - - mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name(); - - if ( mangleGenericParams ) { - std::list< Expression* >& params = refType->get_parameters(); - if ( ! params.empty() ) { + + std::string mangleConcrete( Type * ty ) { + PassVisitor mangler( false, false, false ); + maybeAccept( ty, mangler ); + return mangler.pass.get_mangleName(); + } + + namespace { + Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams ) + : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {} + + Mangler::Mangler( const Mangler &rhs ) : mangleName() { + varNums = rhs.varNums; + nextVarNum = rhs.nextVarNum; + isTopLevel = rhs.isTopLevel; + mangleOverridable = rhs.mangleOverridable; + typeMode = rhs.typeMode; + } + + void Mangler::mangleDecl( DeclarationWithType * declaration ) { + bool wasTopLevel = isTopLevel; + if ( isTopLevel ) { + varNums.clear(); + nextVarNum = 0; + isTopLevel = false; + } // if + mangleName << "__"; + CodeGen::OperatorInfo opInfo; + if ( operatorLookup( declaration->get_name(), opInfo ) ) { + mangleName << opInfo.outputName; + } else { + mangleName << declaration->get_name(); + } // if + mangleName << "__"; + maybeAccept( declaration->get_type(), *visitor ); + if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) { + // want to be able to override autogenerated and intrinsic routines, + // so they need a different name mangling + if ( declaration->get_linkage() == LinkageSpec::AutoGen ) { + mangleName << "autogen__"; + } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) { + mangleName << "intrinsic__"; + } else { + // if we add another kind of overridable function, this has to change + assert( false && "unknown overrideable linkage" ); + } // if + } + isTopLevel = wasTopLevel; + } + + void Mangler::postvisit( ObjectDecl * declaration ) { + mangleDecl( declaration ); + } + + void Mangler::postvisit( FunctionDecl * declaration ) { + mangleDecl( declaration ); + } + + void Mangler::postvisit( VoidType * voidType ) { + printQualifiers( voidType ); + mangleName << "v"; + } + + void Mangler::postvisit( BasicType * basicType ) { + static const char *btLetter[] = { + "b", // Bool + "c", // Char + "Sc", // SignedChar + "Uc", // UnsignedChar + "s", // ShortSignedInt + "Us", // ShortUnsignedInt + "i", // SignedInt + "Ui", // UnsignedInt + "l", // LongSignedInt + "Ul", // LongUnsignedInt + "q", // LongLongSignedInt + "Uq", // LongLongUnsignedInt + "f", // Float + "d", // Double + "r", // LongDouble + "Xf", // FloatComplex + "Xd", // DoubleComplex + "Xr", // LongDoubleComplex + "If", // FloatImaginary + "Id", // DoubleImaginary + "Ir", // LongDoubleImaginary + "w", // SignedInt128 + "Uw", // UnsignedInt128 + }; + + printQualifiers( basicType ); + mangleName << btLetter[ basicType->get_kind() ]; + } + + void Mangler::postvisit( PointerType * pointerType ) { + printQualifiers( pointerType ); + mangleName << "P"; + maybeAccept( pointerType->get_base(), *visitor ); + } + + void Mangler::postvisit( ArrayType * arrayType ) { + // TODO: encode dimension + printQualifiers( arrayType ); + mangleName << "A0"; + maybeAccept( arrayType->get_base(), *visitor ); + } + + void Mangler::postvisit( ReferenceType * refType ) { + printQualifiers( refType ); + mangleName << "R"; + maybeAccept( refType->get_base(), *visitor ); + } + + namespace { + inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) { + std::list< Type* > ret; + std::transform( decls.begin(), decls.end(), std::back_inserter( ret ), + std::mem_fun( &DeclarationWithType::get_type ) ); + return ret; + } + } + + void Mangler::postvisit( FunctionType * functionType ) { + printQualifiers( functionType ); + mangleName << "F"; + std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() ); + acceptAll( returnTypes, *visitor ); mangleName << "_"; - for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) { - TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param ); - assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str()); - maybeAccept( paramType->get_type(), *this ); + std::list< Type* > paramTypes = getTypes( functionType->get_parameters() ); + acceptAll( paramTypes, *visitor ); + mangleName << "_"; + } + + void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) { + printQualifiers( refType ); + + mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name(); + + if ( mangleGenericParams ) { + std::list< Expression* >& params = refType->get_parameters(); + if ( ! params.empty() ) { + mangleName << "_"; + for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) { + TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param ); + assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str()); + maybeAccept( paramType->get_type(), *visitor ); + } + mangleName << "_"; + } } + } + + void Mangler::postvisit( StructInstType * aggregateUseType ) { + mangleRef( aggregateUseType, "s" ); + } + + void Mangler::postvisit( UnionInstType * aggregateUseType ) { + mangleRef( aggregateUseType, "u" ); + } + + void Mangler::postvisit( EnumInstType * aggregateUseType ) { + mangleRef( aggregateUseType, "e" ); + } + + void Mangler::postvisit( TypeInstType * typeInst ) { + VarMapType::iterator varNum = varNums.find( typeInst->get_name() ); + if ( varNum == varNums.end() ) { + mangleRef( typeInst, "t" ); + } else { + printQualifiers( typeInst ); + std::ostringstream numStream; + numStream << varNum->second.first; + switch ( (TypeDecl::Kind )varNum->second.second ) { + case TypeDecl::Dtype: + mangleName << "d"; + break; + case TypeDecl::Ftype: + mangleName << "f"; + break; + case TypeDecl::Ttype: + mangleName << "tVARGS"; + break; + default: + assert( false ); + } // switch + mangleName << numStream.str(); + } // if + } + + void Mangler::postvisit( TupleType * tupleType ) { + printQualifiers( tupleType ); + mangleName << "T"; + acceptAll( tupleType->types, *visitor ); mangleName << "_"; } - } - } - - void Mangler::visit( StructInstType * aggregateUseType ) { - mangleRef( aggregateUseType, "s" ); - } - - void Mangler::visit( UnionInstType * aggregateUseType ) { - mangleRef( aggregateUseType, "u" ); - } - - void Mangler::visit( EnumInstType * aggregateUseType ) { - mangleRef( aggregateUseType, "e" ); - } - - void Mangler::visit( TypeInstType * typeInst ) { - VarMapType::iterator varNum = varNums.find( typeInst->get_name() ); - if ( varNum == varNums.end() ) { - mangleRef( typeInst, "t" ); - } else { - printQualifiers( typeInst ); - std::ostringstream numStream; - numStream << varNum->second.first; - switch ( (TypeDecl::Kind )varNum->second.second ) { - case TypeDecl::Dtype: - mangleName << "d"; - break; - case TypeDecl::Ftype: - mangleName << "f"; - break; - case TypeDecl::Ttype: - mangleName << "tVARGS"; - break; - default: - assert( false ); - } // switch - mangleName << numStream.str(); - } // if - } - - void Mangler::visit( TupleType * tupleType ) { - printQualifiers( tupleType ); - mangleName << "T"; - acceptAll( tupleType->types, *this ); - mangleName << "_"; - } - - void Mangler::visit( VarArgsType * varArgsType ) { - printQualifiers( varArgsType ); - mangleName << "VARGS"; - } - - void Mangler::visit( ZeroType * ) { - mangleName << "Z"; - } - - void Mangler::visit( OneType * ) { - mangleName << "O"; - } - - void Mangler::visit( TypeDecl * decl ) { - static const char *typePrefix[] = { "BT", "BD", "BF" }; - mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name; - } - - void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) { - for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) { - os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl; - } // for - } - - void Mangler::printQualifiers( Type * type ) { - // skip if not including qualifiers - if ( typeMode ) return; - - if ( ! type->get_forall().empty() ) { - std::list< std::string > assertionNames; - int tcount = 0, dcount = 0, fcount = 0, vcount = 0; - mangleName << "A"; - for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) { - switch ( (*i)->get_kind() ) { - case TypeDecl::Dtype: - dcount++; - break; - case TypeDecl::Ftype: - fcount++; - break; - case TypeDecl::Ttype: - vcount++; - break; - default: - assert( false ); - } // switch - varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() ); - for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) { - Mangler sub_mangler( mangleOverridable, typeMode, mangleGenericParams ); - sub_mangler.nextVarNum = nextVarNum; - sub_mangler.isTopLevel = false; - sub_mangler.varNums = varNums; - (*assert)->accept( sub_mangler ); - assertionNames.push_back( sub_mangler.mangleName.str() ); + + void Mangler::postvisit( VarArgsType * varArgsType ) { + printQualifiers( varArgsType ); + mangleName << "VARGS"; + } + + void Mangler::postvisit( ZeroType * ) { + mangleName << "Z"; + } + + void Mangler::postvisit( OneType * ) { + mangleName << "O"; + } + + void Mangler::postvisit( TypeDecl * decl ) { + static const char *typePrefix[] = { "BT", "BD", "BF" }; + mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name; + } + + __attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) { + for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) { + os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl; } // for - } // for - mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_"; - std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) ); - mangleName << "_"; - } // if - if ( type->get_const() ) { - mangleName << "C"; - } // if - if ( type->get_volatile() ) { - mangleName << "V"; - } // if - if ( type->get_mutex() ) { - mangleName << "M"; - } // if - // Removed due to restrict not affecting function compatibility in GCC -// if ( type->get_isRestrict() ) { -// mangleName << "E"; -// } // if - if ( type->get_lvalue() ) { - // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues - mangleName << "L"; - } - if ( type->get_atomic() ) { - mangleName << "A"; - } // if - } + } + + void Mangler::printQualifiers( Type * type ) { + // skip if not including qualifiers + if ( typeMode ) return; + + if ( ! type->get_forall().empty() ) { + std::list< std::string > assertionNames; + int tcount = 0, dcount = 0, fcount = 0, vcount = 0; + mangleName << "A"; + for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) { + switch ( (*i)->get_kind() ) { + case TypeDecl::Dtype: + dcount++; + break; + case TypeDecl::Ftype: + fcount++; + break; + case TypeDecl::Ttype: + vcount++; + break; + default: + assert( false ); + } // switch + varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() ); + for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) { + PassVisitor sub_mangler( mangleOverridable, typeMode, mangleGenericParams ); + sub_mangler.pass.nextVarNum = nextVarNum; + sub_mangler.pass.isTopLevel = false; + sub_mangler.pass.varNums = varNums; + (*assert)->accept( sub_mangler ); + assertionNames.push_back( sub_mangler.pass.mangleName.str() ); + } // for + } // for + mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_"; + std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) ); + mangleName << "_"; + } // if + if ( type->get_const() ) { + mangleName << "C"; + } // if + if ( type->get_volatile() ) { + mangleName << "V"; + } // if + if ( type->get_mutex() ) { + mangleName << "M"; + } // if + // Removed due to restrict not affecting function compatibility in GCC + // if ( type->get_isRestrict() ) { + // mangleName << "E"; + // } // if + if ( type->get_lvalue() ) { + // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues + mangleName << "L"; + } + if ( type->get_atomic() ) { + mangleName << "A"; + } // if + } + } // namespace + } // namespace Mangler } // namespace SymTab Index: src/SymTab/Mangler.h =================================================================== --- src/SymTab/Mangler.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/SymTab/Mangler.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -25,61 +25,13 @@ namespace SymTab { - /// Mangles names to a unique C identifier - class Mangler : public Visitor { - public: + namespace Mangler { /// Mangle syntax tree object; primary interface to clients - template< typename SynTreeClass > - static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true ); + std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true ); + /// Mangle a type name; secondary interface - static std::string mangleType( Type* ty ); + std::string mangleType( Type* ty ); /// Mangle ignoring generic type parameters - static std::string mangleConcrete( Type* ty ); - - - virtual void visit( ObjectDecl *declaration ); - virtual void visit( FunctionDecl *declaration ); - virtual void visit( TypeDecl *declaration ); - - virtual void visit( VoidType *voidType ); - virtual void visit( BasicType *basicType ); - 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 ); - virtual void visit( UnionInstType *aggregateUseType ); - virtual void visit( EnumInstType *aggregateUseType ); - virtual void visit( TypeInstType *aggregateUseType ); - virtual void visit( TupleType *tupleType ); - virtual void visit( VarArgsType *varArgsType ); - virtual void visit( ZeroType *zeroType ); - virtual void visit( OneType *oneType ); - - std::string get_mangleName() { return mangleName.str(); } - private: - std::ostringstream mangleName; ///< Mangled name being constructed - typedef std::map< std::string, std::pair< int, int > > VarMapType; - VarMapType varNums; ///< Map of type variables to indices - int nextVarNum; ///< Next type variable index - bool isTopLevel; ///< Is the Mangler at the top level - bool mangleOverridable; ///< Specially mangle overridable built-in methods - bool typeMode; ///< Produce a unique mangled name for a type - bool mangleGenericParams; ///< Include generic parameters in name mangling if true - - Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams ); - Mangler( const Mangler & ); - - void mangleDecl( DeclarationWithType *declaration ); - void mangleRef( ReferenceToType *refType, std::string prefix ); - - void printQualifiers( Type *type ); - }; // Mangler - - template< typename SynTreeClass > - std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) { - Mangler mangler( mangleOverridable, typeMode, mangleGenericParams ); - maybeAccept( decl, mangler ); - return mangler.get_mangleName(); - } + std::string mangleConcrete( Type* ty ); + } // Mangler } // SymTab Index: src/SynTree/AggregateDecl.cc =================================================================== --- src/SynTree/AggregateDecl.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/SynTree/AggregateDecl.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -92,4 +92,7 @@ } else if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) { return constExpr->intValue(); + // can be -1, +1, etc. + // } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) { + // if ( untypedExpr-> ) } else { assertf( false, "Unhandled expression type in getConstValue for enumerators: %s", toString( expr ).c_str() ); Index: src/SynTree/CompoundStmt.cc =================================================================== --- src/SynTree/CompoundStmt.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/SynTree/CompoundStmt.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -64,6 +64,5 @@ } if ( ! declMap.empty() ) { - VarExprReplacer replacer( declMap ); - accept( replacer ); + VarExprReplacer::replace( this, declMap ); } } Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/SynTree/Expression.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -108,8 +108,7 @@ // assert( inst->baseEnum ); // EnumDecl * decl = inst->baseEnum; - // for ( Declaration * member : decl->members ) { - // if ( member == _var ) { - // type->set_lvalue( false ); - // } + // long long int value; + // if ( decl->valueOf( var, value ) ) { + // type->set_lvalue( false ); // } // } @@ -416,5 +415,5 @@ } else { // references have been removed, in which case dereference returns an lvalue of the base type. - ret->get_result()->set_lvalue( true ); + ret->result->set_lvalue( true ); } } Index: src/SynTree/FunctionDecl.cc =================================================================== --- src/SynTree/FunctionDecl.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/SynTree/FunctionDecl.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -49,6 +49,5 @@ } if ( ! declMap.empty() ) { - VarExprReplacer replacer( declMap ); - accept( replacer ); + VarExprReplacer::replace( this, declMap ); } } Index: src/SynTree/Label.h =================================================================== --- src/SynTree/Label.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/SynTree/Label.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -33,5 +33,5 @@ std::list< Attribute * >& get_attributes() { return attributes; } - operator std::string() { return name; } + operator std::string() const { return name; } bool empty() { return name.empty(); } private: Index: src/SynTree/TypeSubstitution.cc =================================================================== --- src/SynTree/TypeSubstitution.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/SynTree/TypeSubstitution.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -107,26 +107,27 @@ void TypeSubstitution::normalize() { + PassVisitor sub( *this, true ); do { - subCount = 0; - freeOnly = true; + sub.pass.subCount = 0; + sub.pass.freeOnly = true; for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) { - i->second = i->second->acceptMutator( *this ); + i->second = i->second->acceptMutator( sub ); } - } while ( subCount ); -} - -Type * TypeSubstitution::mutate( TypeInstType *inst ) { - BoundVarsType::const_iterator bound = boundVars.find( inst->get_name() ); + } while ( sub.pass.subCount ); +} + +Type * TypeSubstitution::Substituter::postmutate( TypeInstType *inst ) { + BoundVarsType::const_iterator bound = boundVars.find( inst->name ); if ( bound != boundVars.end() ) return inst; - TypeEnvType::const_iterator i = typeEnv.find( inst->get_name() ); - if ( i == typeEnv.end() ) { + TypeEnvType::const_iterator i = sub.typeEnv.find( inst->get_name() ); + if ( i == sub.typeEnv.end() ) { return inst; } else { -/// std::cout << "found " << inst->get_name() << ", replacing with "; -/// i->second->print( std::cout ); -/// std::cout << std::endl; +/// std::cerr << "found " << inst->get_name() << ", replacing with "; +/// i->second->print( std::cerr ); +/// std::cerr << std::endl; subCount++; - Type *newtype = i->second->clone(); + Type * newtype = i->second->clone(); newtype->get_qualifiers() |= inst->get_qualifiers(); delete inst; @@ -135,7 +136,7 @@ } -Expression * TypeSubstitution::mutate( NameExpr *nameExpr ) { - VarEnvType::const_iterator i = varEnv.find( nameExpr->get_name() ); - if ( i == varEnv.end() ) { +Expression * TypeSubstitution::Substituter::postmutate( NameExpr * nameExpr ) { + VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name ); + if ( i == sub.varEnv.end() ) { return nameExpr; } else { @@ -146,87 +147,38 @@ } -template< typename TypeClass > -Type *TypeSubstitution::handleType( TypeClass *type ) { - ValueGuard oldBoundVars( boundVars ); +void TypeSubstitution::Substituter::premutate( Type * type ) { + GuardValue( boundVars ); // bind type variables from forall-qualifiers if ( freeOnly ) { - for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) { - boundVars.insert( (*tyvar )->get_name() ); + for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) { + boundVars.insert( (*tyvar)->name ); } // for } // if - Type *ret = Mutator::mutate( type ); - return ret; } template< typename TypeClass > -Type *TypeSubstitution::handleAggregateType( TypeClass *type ) { - ValueGuard oldBoundVars( boundVars ); +void TypeSubstitution::Substituter::handleAggregateType( TypeClass * type ) { + GuardValue( boundVars ); // bind type variables from forall-qualifiers if ( freeOnly ) { - for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) { - boundVars.insert( (*tyvar )->get_name() ); + for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) { + boundVars.insert( (*tyvar)->name ); } // for // bind type variables from generic type instantiations std::list< TypeDecl* > *baseParameters = type->get_baseParameters(); - if ( baseParameters && ! type->get_parameters().empty() ) { + if ( baseParameters && ! type->parameters.empty() ) { for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters->begin(); tyvar != baseParameters->end(); ++tyvar ) { - boundVars.insert( (*tyvar)->get_name() ); + boundVars.insert( (*tyvar)->name ); } // for } // if } // if - Type *ret = Mutator::mutate( type ); - return ret; -} - -Type * TypeSubstitution::mutate( VoidType *voidType ) { - return handleType( voidType ); -} - -Type * TypeSubstitution::mutate( BasicType *basicType ) { - return handleType( basicType ); -} - -Type * TypeSubstitution::mutate( PointerType *pointerType ) { - return handleType( pointerType ); -} - -Type * TypeSubstitution::mutate( ArrayType *arrayType ) { - return handleType( arrayType ); -} - -Type * TypeSubstitution::mutate( FunctionType *functionType ) { - return handleType( functionType ); -} - -Type * TypeSubstitution::mutate( StructInstType *aggregateUseType ) { - return handleAggregateType( aggregateUseType ); -} - -Type * TypeSubstitution::mutate( UnionInstType *aggregateUseType ) { - return handleAggregateType( aggregateUseType ); -} - -Type * TypeSubstitution::mutate( EnumInstType *aggregateUseType ) { - return handleType( aggregateUseType ); -} - -Type * TypeSubstitution::mutate( TraitInstType *aggregateUseType ) { - return handleType( aggregateUseType ); -} - -Type * TypeSubstitution::mutate( TupleType *tupleType ) { - return handleType( tupleType ); -} - -Type * TypeSubstitution::mutate( VarArgsType *varArgsType ) { - return handleType( varArgsType ); -} - -Type * TypeSubstitution::mutate( ZeroType *zeroType ) { - return handleType( zeroType ); -} - -Type * TypeSubstitution::mutate( OneType *oneType ) { - return handleType( oneType ); +} + +void TypeSubstitution::Substituter::premutate( StructInstType * aggregateUseType ) { + handleAggregateType( aggregateUseType ); +} + +void TypeSubstitution::Substituter::premutate( UnionInstType *aggregateUseType ) { + handleAggregateType( aggregateUseType ); } Index: src/SynTree/TypeSubstitution.h =================================================================== --- src/SynTree/TypeSubstitution.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/SynTree/TypeSubstitution.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -27,9 +27,7 @@ #include "SynTree/Declaration.h" // for TypeDecl, Declaration (ptr only) #include "SynTree/Expression.h" // for Expression (ptr only), NameExpr (p... -#include "SynTree/Mutator.h" // for Mutator #include "SynTree/Type.h" // for Type, ArrayType (ptr only), BasicT... -class TypeSubstitution : public Mutator { - typedef Mutator Parent; +class TypeSubstitution { public: TypeSubstitution(); @@ -64,25 +62,7 @@ TypeSubstitution *clone() const { return new TypeSubstitution( *this ); } private: - virtual Type* mutate(TypeInstType *aggregateUseType); - virtual Expression* mutate(NameExpr *nameExpr); - /// Records type variable bindings from forall-statements - template< typename TypeClass > Type *handleType( TypeClass *type ); - /// Records type variable bindings from forall-statements and instantiations of generic types - template< typename TypeClass > Type *handleAggregateType( TypeClass *type ); - - virtual Type* mutate(VoidType *basicType); - virtual Type* mutate(BasicType *basicType); - virtual Type* mutate(PointerType *pointerType); - virtual Type* mutate(ArrayType *arrayType); - virtual Type* mutate(FunctionType *functionType); - virtual Type* mutate(StructInstType *aggregateUseType); - virtual Type* mutate(UnionInstType *aggregateUseType); - virtual Type* mutate(EnumInstType *aggregateUseType); - virtual Type* mutate(TraitInstType *aggregateUseType); - virtual Type* mutate(TupleType *tupleType); - virtual Type* mutate(VarArgsType *varArgsType); - virtual Type* mutate(ZeroType *zeroType); - virtual Type* mutate(OneType *oneType); + // Mutator that performs the substitution + struct Substituter; // TODO: worry about traversing into a forall-qualified function type or type decl with assertions @@ -97,10 +77,6 @@ typedef std::map< std::string, Type* > TypeEnvType; typedef std::map< std::string, Expression* > VarEnvType; - typedef std::set< std::string > BoundVarsType; TypeEnvType typeEnv; VarEnvType varEnv; - BoundVarsType boundVars; - int subCount; - bool freeOnly; }; @@ -134,20 +110,44 @@ template< typename FormalIterator, typename ActualIterator > -TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) -{ +TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) { add( formalBegin, formalEnd, actualBegin ); } + +// include needs to happen after TypeSubstitution is defined so that both TypeSubstitution and +// PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals. +#include "Common/PassVisitor.h" + +// definitition must happen after PassVisitor is included so that WithGuards can be used +struct TypeSubstitution::Substituter : public WithGuards { + Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {} + + Type * postmutate( TypeInstType * aggregateUseType ); + Expression * postmutate( NameExpr * nameExpr ); + + /// Records type variable bindings from forall-statements + void premutate( Type * type ); + /// Records type variable bindings from forall-statements and instantiations of generic types + template< typename TypeClass > void handleAggregateType( TypeClass * type ); + + void premutate( StructInstType * aggregateUseType ); + void premutate( UnionInstType * aggregateUseType ); + + TypeSubstitution & sub; + int subCount = 0; + bool freeOnly; + typedef std::set< std::string > BoundVarsType; + BoundVarsType boundVars; +}; template< typename SynTreeClass > int TypeSubstitution::apply( SynTreeClass *&input ) { assert( input ); - subCount = 0; - freeOnly = false; - input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) ); + PassVisitor sub( *this, false ); + input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) ); assert( input ); -/// std::cout << "substitution result is: "; -/// newType->print( std::cout ); -/// std::cout << std::endl; - return subCount; +/// std::cerr << "substitution result is: "; +/// newType->print( std::cerr ); +/// std::cerr << std::endl; + return sub.pass.subCount; } @@ -155,12 +155,11 @@ int TypeSubstitution::applyFree( SynTreeClass *&input ) { assert( input ); - subCount = 0; - freeOnly = true; - input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) ); + PassVisitor sub( *this, true ); + input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) ); assert( input ); -/// std::cout << "substitution result is: "; -/// newType->print( std::cout ); -/// std::cout << std::endl; - return subCount; +/// std::cerr << "substitution result is: "; +/// newType->print( std::cerr ); +/// std::cerr << std::endl; + return sub.pass.subCount; } Index: src/SynTree/VarExprReplacer.cc =================================================================== --- src/SynTree/VarExprReplacer.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/SynTree/VarExprReplacer.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -16,18 +16,49 @@ #include // for operator<<, basic_ostream, ostream, basic_o... +#include "Common/PassVisitor.h" #include "Declaration.h" // for operator<<, DeclarationWithType #include "Expression.h" // for VariableExpr #include "VarExprReplacer.h" -VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {} +namespace VarExprReplacer { + namespace { + /// Visitor that replaces the declarations that VariableExprs refer to, according to the supplied mapping + struct VarExprReplacer { + private: + const DeclMap & declMap; + bool debug; + public: + VarExprReplacer( const DeclMap & declMap, bool debug = false ); -// replace variable with new node from decl map -void VarExprReplacer::visit( VariableExpr * varExpr ) { - // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are) - if ( declMap.count( varExpr->get_var() ) ) { - if ( debug ) { - std::cerr << "replacing variable reference: " << (void*)varExpr->get_var() << " " << varExpr->get_var() << " with " << (void*)declMap.at( varExpr->get_var() ) << " " << declMap.at( varExpr->get_var() ) << std::endl; + // replace variable with new node from decl map + void previsit( VariableExpr * varExpr ); + }; + } + + void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) { + PassVisitor replacer( declMap, debug ); + maybeAccept( node, replacer ); + } + + namespace { + VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {} + + // replace variable with new node from decl map + void VarExprReplacer::previsit( VariableExpr * varExpr ) { + // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are) + if ( declMap.count( varExpr->var ) ) { + if ( debug ) { + std::cerr << "replacing variable reference: " << (void*)varExpr->var << " " << varExpr->var << " with " << (void*)declMap.at( varExpr->var ) << " " << declMap.at( varExpr->var ) << std::endl; + } + varExpr->var = declMap.at( varExpr->var ); + } } - varExpr->set_var( declMap.at( varExpr->get_var() ) ); } -} +} // namespace VarExprReplacer + + + + + + + Index: src/SynTree/VarExprReplacer.h =================================================================== --- src/SynTree/VarExprReplacer.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/SynTree/VarExprReplacer.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -23,22 +23,9 @@ class VariableExpr; -/// Visitor that replaces the declarations that VariableExprs refer to, according to the supplied mapping -class VarExprReplacer : public Visitor { -public: +namespace VarExprReplacer { typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap; -private: - const DeclMap & declMap; - bool debug; -public: - VarExprReplacer( const DeclMap & declMap, bool debug = false ); - // replace variable with new node from decl map - virtual void visit( VariableExpr * varExpr ); - - static void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false ) { - VarExprReplacer replacer( declMap, debug ); - maybeAccept( node, replacer ); - } -}; + void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false ); +} // Local Variables: // Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/Tuples/TupleExpansion.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -36,9 +36,7 @@ namespace Tuples { namespace { - struct MemberTupleExpander final : public Mutator { - typedef Mutator Parent; - using Parent::mutate; - - virtual Expression * mutate( UntypedMemberExpr * memberExpr ) override; + struct MemberTupleExpander final : public WithShortCircuiting, public WithVisitorRef { + void premutate( UntypedMemberExpr * ) { visit_children = false; } + Expression * postmutate( UntypedMemberExpr * memberExpr ); }; @@ -79,5 +77,5 @@ void expandMemberTuples( std::list< Declaration * > & translationUnit ) { - MemberTupleExpander expander; + PassVisitor expander; mutateAll( translationUnit, expander ); } @@ -109,10 +107,10 @@ // construct a new UntypedMemberExpr with the correct structure , and recursively // expand that member expression. - MemberTupleExpander expander; - UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->get_aggregate(), aggr->clone() ); - UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member(), inner ); + PassVisitor expander; + UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->aggregate, aggr->clone() ); + UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member, inner ); inner->location = newMemberExpr->location = loc; - memberExpr->set_member(nullptr); - memberExpr->set_aggregate(nullptr); + memberExpr->member = nullptr; + memberExpr->aggregate = nullptr; delete memberExpr; return newMemberExpr->acceptMutator( expander ); @@ -126,12 +124,12 @@ } - Expression * MemberTupleExpander::mutate( UntypedMemberExpr * memberExpr ) { - if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->get_member() ) ) { - Expression * aggr = memberExpr->get_aggregate()->clone()->acceptMutator( *this ); + Expression * MemberTupleExpander::postmutate( UntypedMemberExpr * memberExpr ) { + if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->member ) ) { + Expression * aggr = memberExpr->aggregate->clone()->acceptMutator( *visitor ); // 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::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr ); aggr = new UniqueExpr( aggr ); - for ( Expression *& expr : tupleExpr->get_exprs() ) { + for ( Expression *& expr : tupleExpr->exprs ) { expr = reconstructMemberExpr( expr, aggr, memberExpr->location ); expr->location = memberExpr->location; @@ -143,5 +141,5 @@ // there may be a tuple expr buried in the aggregate // xxx - this is a memory leak - UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member()->clone(), memberExpr->get_aggregate()->acceptMutator( *this ) ); + UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member->clone(), memberExpr->aggregate->acceptMutator( *visitor ) ); newMemberExpr->location = memberExpr->location; return newMemberExpr; Index: src/benchmark/Makefile.am =================================================================== --- src/benchmark/Makefile.am (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/benchmark/Makefile.am (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -59,4 +59,8 @@ @echo -e '\t"githash": "'${githash}'",' @echo -e '\t"arch": "' ${arch} '",' + @echo -e '\t"compile": {' + @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :' + @echo -e '\t\t"dummy" : {}' + @echo -e '\t},' @echo -e '\t"ctxswitch": {' @echo -en '\t\t"coroutine":' @@ -198,5 +202,5 @@ waitfor-cfa1$(EXEEXT): - ${CC} schedext/cfa1.c -DBENCH_N=500000 -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} + @${CC} schedext/cfa1.c -DBENCH_N=500000 -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} waitfor-cfa2$(EXEEXT): Index: src/benchmark/Makefile.in =================================================================== --- src/benchmark/Makefile.in (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/benchmark/Makefile.in (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -473,4 +473,8 @@ @echo -e '\t"githash": "'${githash}'",' @echo -e '\t"arch": "' ${arch} '",' + @echo -e '\t"compile": {' + @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :' + @echo -e '\t\t"dummy" : {}' + @echo -e '\t},' @echo -e '\t"ctxswitch": {' @echo -en '\t\t"coroutine":' @@ -607,5 +611,5 @@ waitfor-cfa1$(EXEEXT): - ${CC} schedext/cfa1.c -DBENCH_N=500000 -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} + @${CC} schedext/cfa1.c -DBENCH_N=500000 -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} waitfor-cfa2$(EXEEXT): Index: src/driver/cfa.cc =================================================================== --- src/driver/cfa.cc (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/driver/cfa.cc (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -277,4 +277,8 @@ args[nargs] = "--undefined=__cfaabi_dbg_bits_write"; nargs += 1; + args[nargs] = "-Xlinker"; + nargs += 1; + args[nargs] = "--undefined=__cfaabi_interpose_startup"; + nargs += 1; } // if Index: src/libcfa/bits/locks.h =================================================================== --- src/libcfa/bits/locks.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/bits/locks.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -9,7 +9,7 @@ // Author : Thierry Delisle // Created On : Tue Oct 31 15:14:38 2017 -// Last Modified By : -- -// Last Modified On : -- -// Update Count : 0 +// Last Modified By : Peter A. Buhr +// Last Modified On : Fri Dec 8 16:02:22 2017 +// Update Count : 1 // @@ -24,9 +24,11 @@ #elif defined( __i386 ) || defined( __x86_64 ) #define Pause() __asm__ __volatile__ ( "pause" : : : ) +#elif defined( __ARM_ARCH ) + #define Pause() __asm__ __volatile__ ( "nop" : : : ) #else #error unsupported architecture #endif -#if defined( __i386 ) || defined( __x86_64 ) +#if defined( __i386 ) || defined( __x86_64 ) || defined( __ARM_ARCH ) // Intel recommendation #define __ALIGN__ __attribute__(( aligned (128) )) @@ -37,8 +39,8 @@ #endif -#if defined( __x86_64 ) +#if __SIZEOF_SIZE_T__ == 8 #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_8( &(lock), 1 ) == 0 #define __lock_release( lock ) __sync_lock_release_8( &(lock) ); -#elif defined( __i386 ) +#elif __SIZEOF_SIZE_T__ == 4 #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_4( &(lock), 1 ) == 0 #define __lock_release( lock ) __sync_lock_release_4( &(lock) ); @@ -48,5 +50,5 @@ struct __spinlock_t { - __ALIGN__ volatile uintptr_t lock; + __ALIGN__ volatile size_t lock; #ifdef __CFA_DEBUG__ const char * prev_name; @@ -56,6 +58,12 @@ #ifdef __cforall + extern "C" { + extern void disable_interrupts(); + extern void enable_interrupts_noPoll(); + } + extern void yield( unsigned int ); extern thread_local struct thread_desc * volatile this_thread; + extern thread_local struct processor * volatile this_processor; static inline void ?{}( __spinlock_t & this ) { @@ -66,10 +74,11 @@ static inline _Bool try_lock ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { _Bool result = __lock_test_and_test_and_set( this.lock ); - __cfaabi_dbg_debug_do( - if( result ) { + if( result ) { + disable_interrupts(); + __cfaabi_dbg_debug_do( this.prev_name = caller; this.prev_thrd = this_thread; - } - ) + ) + } return result; } @@ -97,4 +106,5 @@ #endif } + disable_interrupts(); __cfaabi_dbg_debug_do( this.prev_name = caller; @@ -103,17 +113,19 @@ } - // Lock the spinlock, spin if already acquired - static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { - for ( unsigned int i = 1;; i += 1 ) { - if ( __lock_test_and_test_and_set( this.lock ) ) break; - yield( i ); - } - __cfaabi_dbg_debug_do( - this.prev_name = caller; - this.prev_thrd = this_thread; - ) - } + // // Lock the spinlock, yield if already acquired + // static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { + // for ( unsigned int i = 1;; i += 1 ) { + // if ( __lock_test_and_test_and_set( this.lock ) ) break; + // yield( i ); + // } + // disable_interrupts(); + // __cfaabi_dbg_debug_do( + // this.prev_name = caller; + // this.prev_thrd = this_thread; + // ) + // } static inline void unlock( __spinlock_t & this ) { + enable_interrupts_noPoll(); __lock_release( this.lock ); } Index: src/libcfa/bits/signal.h =================================================================== --- src/libcfa/bits/signal.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/libcfa/bits/signal.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,65 @@ +// +// 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. +// +// bits/signal.h -- Helper functions and defines to use signals +// +// Author : Thierry Delisle +// Created On : Thu Jan 25 16:06:29 2018 +// Last Modified By : +// Last Modified On : +// Update Count : +// + +#pragma once + +#include "bits/debug.h" +#include "bits/defs.h" + +extern "C" { +#include +#define __USE_GNU +#include +#undef __USE_GNU +#include +#include +} + +// Short hands for signal context information +#define __CFA_SIGCXT__ ucontext_t * +#define __CFA_SIGPARMS__ __attribute__((unused)) int sig, __attribute__((unused)) siginfo_t *sfp, __attribute__((unused)) __CFA_SIGCXT__ cxt + +// Sigaction wrapper : register an signal handler +static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ) { + struct sigaction act; + + act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler; + act.sa_flags = flags; + + if ( sigaction( sig, &act, NULL ) == -1 ) { + __cfaabi_dbg_print_buffer_decl( + " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n", + sig, handler, flags, errno, strerror( errno ) + ); + _exit( EXIT_FAILURE ); + } +} + +// Sigaction wrapper : restore default handler +static void __kernel_sigdefault( int sig ) { + struct sigaction act; + + act.sa_handler = SIG_DFL; + act.sa_flags = 0; + sigemptyset( &act.sa_mask ); + + if ( sigaction( sig, &act, NULL ) == -1 ) { + __cfaabi_dbg_print_buffer_decl( + " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n", + sig, errno, strerror( errno ) + ); + _exit( EXIT_FAILURE ); + } +} Index: src/libcfa/concurrency/CtxSwitch-armv7l.S =================================================================== --- src/libcfa/concurrency/CtxSwitch-armv7l.S (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/libcfa/concurrency/CtxSwitch-armv7l.S (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,62 @@ + @ 32 bit ARM context switch + @ This function assumes that r9 has no special meaning on the platform it's + @ being built on. + @ If r9 is special, uncomment the following line and it will be left alone + + @ #define R9_SPECIAL + + #define PTR_BYTE 4 + #define SP_OFFSET ( 0 * PTR_BYTE ) + #define FP_OFFSET ( 1 * PTR_BYTE ) + #define PC_OFFSET ( 2 * PTR_BYTE ) + + .text + .align 2 + .global CtxSwitch + .type CtxSwitch, %function + +CtxSwitch: + @ save callee-saved registers: r4-r8, r10, r11, r13(sp) (plus r9 depending on platform specification) + @ I've seen reference to 31 registers on 64-bit, if this is the case, more need to be saved + @ save thread state registers: r14(lr) + @ r12(ip) is intra-procedure-call scratch register, does not need saving between function calls + + #ifdef R9_SPECIAL + stmfd r13!, {r4-r8,r10,r11,r14} + #else + stmfd r13!, {r4-r11,r14} + #endif // R9_SPECIAL + + @ save floating point registers: s16-s31 + vstmdb r13!, {s16-s31} + + @ save frame pointer and stack pointer to outgoing datastructure + str sp, [r0, #SP_OFFSET] + str fp, [r0, #FP_OFFSET] + + @ restore frame pointer and stack pointer from incoming datastructure + ldr fp, [r1, #FP_OFFSET] + ldr sp, [r1, #SP_OFFSET] + + @ restore floating point registers: s16-s31 + vldm r13!, {s16-s31} + @ restore r14(lr) + @ restore 64-bit extra registers? + @ restore callee-saved registers: r4-r8, r10, r11, r13 + + #ifdef R9_SPECIAL + ldmfd r13!, {r4-r8,r10,r11,r15} + #else + ldmfd r13!, {r4-r11,r14} @ loading r14 back into r15 returns + + mov r15, r14 + #endif // R9_SPECIAL + + .text + .align 2 + .global CtxInvokeStub + .type CtxInvokeStub, %function + +CtxInvokeStub: + ldmfd r13!, {r0-r1} + mov r15, r1 Index: src/libcfa/concurrency/invoke.c =================================================================== --- src/libcfa/concurrency/invoke.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/concurrency/invoke.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -10,6 +10,6 @@ // Created On : Tue Jan 17 12:27:26 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jul 21 22:28:33 2017 -// Update Count : 1 +// Last Modified On : Tue Jan 23 14:04:56 2018 +// Update Count : 2 // @@ -133,4 +133,21 @@ ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F; //Vol. 1 8-7 + +#elif defined( __ARM_ARCH ) + + struct FakeStack { + float fpRegs[16]; // floating point registers + void *intRegs[9]; // integer/pointer registers + void *arg[2]; // placeholder for this pointer + }; + + ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack ); + ((struct machine_context_t *)stack->context)->FP = NULL; + + struct FakeStack *fs = (struct FakeStack *)((struct machine_context_t *)stack->context)->SP; + + fs->intRegs[8] = CtxInvokeStub; + fs->arg[0] = this; + fs->arg[1] = invoke; #else #error Only __i386__ and __x86_64__ is supported for threads in cfa Index: src/libcfa/concurrency/invoke.h =================================================================== --- src/libcfa/concurrency/invoke.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/concurrency/invoke.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -10,6 +10,6 @@ // Created On : Tue Jan 17 12:27:26 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jul 21 22:28:56 2017 -// Update Count : 1 +// Last Modified On : Tue Jan 23 14:55:46 2018 +// Update Count : 3 // @@ -134,4 +134,10 @@ // instrusive link field for threads struct thread_desc * next; + + __cfaabi_dbg_debug_do( + // instrusive link field for debugging + struct thread_desc * dbg_next; + struct thread_desc * dbg_prev; + ) }; @@ -203,4 +209,9 @@ "movl %%ebp,%1\n" \ : "=rm" (ctx.SP), "=rm" (ctx.FP) ) + #elif defined( __ARM_ARCH ) + #define CtxGet( ctx ) __asm__ ( \ + "mov %0,%%sp\n" \ + "mov %1,%%r11\n" \ + : "=rm" (ctx.SP), "=rm" (ctx.FP) ) #endif Index: src/libcfa/concurrency/kernel.c =================================================================== --- src/libcfa/concurrency/kernel.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/concurrency/kernel.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -10,10 +10,11 @@ // Created On : Tue Jan 17 12:27:26 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jul 21 22:33:18 2017 -// Update Count : 2 +// Last Modified On : Fri Dec 8 16:23:33 2017 +// Update Count : 3 // //C Includes #include +#define ftype `ftype` extern "C" { #include @@ -23,4 +24,5 @@ #include } +#undef ftype //CFA Includes @@ -240,4 +242,5 @@ void finishRunning(processor * this) with( this->finish ) { if( action_code == Release ) { + verify( disable_preempt_count > 1 ); unlock( *lock ); } @@ -246,8 +249,10 @@ } else if( action_code == Release_Schedule ) { + verify( disable_preempt_count > 1 ); unlock( *lock ); ScheduleThread( thrd ); } else if( action_code == Release_Multi ) { + verify( disable_preempt_count > lock_count ); for(int i = 0; i < lock_count; i++) { unlock( *locks[i] ); @@ -363,5 +368,5 @@ this_processor->finish.lock = lock; - verify( disable_preempt_count > 0 ); + verify( disable_preempt_count > 1 ); suspend(); verify( disable_preempt_count > 0 ); @@ -389,5 +394,5 @@ this_processor->finish.thrd = thrd; - verify( disable_preempt_count > 0 ); + verify( disable_preempt_count > 1 ); suspend(); verify( disable_preempt_count > 0 ); @@ -514,4 +519,9 @@ } +//============================================================================================= +// Unexpected Terminating logic +//============================================================================================= + + static __spinlock_t kernel_abort_lock; static __spinlock_t kernel_debug_lock; @@ -609,4 +619,37 @@ } +//----------------------------------------------------------------------------- +// Debug +__cfaabi_dbg_debug_do( + struct { + thread_desc * tail; + } __cfaabi_dbg_thread_list = { NULL }; + + void __cfaabi_dbg_thread_register( thread_desc * thrd ) { + if( !__cfaabi_dbg_thread_list.tail ) { + __cfaabi_dbg_thread_list.tail = thrd; + return; + } + __cfaabi_dbg_thread_list.tail->dbg_next = thrd; + thrd->dbg_prev = __cfaabi_dbg_thread_list.tail; + __cfaabi_dbg_thread_list.tail = thrd; + } + + void __cfaabi_dbg_thread_unregister( thread_desc * thrd ) { + thread_desc * prev = thrd->dbg_prev; + thread_desc * next = thrd->dbg_next; + + if( next ) { next->dbg_prev = prev; } + else { + assert( __cfaabi_dbg_thread_list.tail == thrd ); + __cfaabi_dbg_thread_list.tail = prev; + } + + if( prev ) { prev->dbg_next = next; } + + thrd->dbg_prev = NULL; + thrd->dbg_next = NULL; + } +) // Local Variables: // // mode: c // Index: src/libcfa/concurrency/kernel_private.h =================================================================== --- src/libcfa/concurrency/kernel_private.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/concurrency/kernel_private.h (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -85,4 +85,9 @@ extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst); +__cfaabi_dbg_debug_do( + extern void __cfaabi_dbg_thread_register ( thread_desc * thrd ); + extern void __cfaabi_dbg_thread_unregister( thread_desc * thrd ); +) + //----------------------------------------------------------------------------- // Utils Index: src/libcfa/concurrency/monitor.c =================================================================== --- src/libcfa/concurrency/monitor.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/concurrency/monitor.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -53,10 +53,4 @@ static inline __lock_size_t aggregate ( monitor_desc * storage [], const __waitfor_mask_t & mask ); -#ifndef __CFA_LOCK_NO_YIELD -#define DO_LOCK lock_yield -#else -#define DO_LOCK lock -#endif - //----------------------------------------------------------------------------- // Useful defines @@ -90,6 +84,8 @@ static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) { // Lock the monitor spinlock - DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); + lock( this->lock __cfaabi_dbg_ctx2 ); thread_desc * thrd = this_thread; + + verify( disable_preempt_count > 0 ); __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner); @@ -121,4 +117,7 @@ // Some one else has the monitor, wait in line for it append( this->entry_queue, thrd ); + + verify( disable_preempt_count > 0 ); + BlockInternal( &this->lock ); @@ -138,5 +137,5 @@ static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) { // Lock the monitor spinlock - DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); + lock( this->lock __cfaabi_dbg_ctx2 ); thread_desc * thrd = this_thread; @@ -201,6 +200,6 @@ // Leave single monitor void __leave_monitor_desc( monitor_desc * this ) { - // Lock the monitor spinlock, DO_LOCK to reduce contention - DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); + // Lock the monitor spinlock + lock( this->lock __cfaabi_dbg_ctx2 ); __cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner); @@ -248,5 +247,5 @@ // Lock the monitor now - DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); + lock( this->lock __cfaabi_dbg_ctx2 ); disable_interrupts(); @@ -397,6 +396,11 @@ append( this.blocked, &waiter ); + verify( disable_preempt_count == 0 ); + // Lock all monitors (aggregates the locks as well) lock_all( monitors, locks, count ); + + // verifyf( disable_preempt_count == count, "Got %d, expected %d\n", disable_preempt_count, count ); + if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); } // Find the next thread(s) to run @@ -473,6 +477,12 @@ monitor_ctx( this.monitors, this.monitor_count ); + verify( disable_preempt_count == 0 ); + // Lock all monitors (aggregates the locks them as well) lock_all( monitors, locks, count ); + + // verify( disable_preempt_count == count ); + if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); } + // Create the node specific to this wait operation @@ -737,5 +747,5 @@ static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) { for( __lock_size_t i = 0; i < count; i++ ) { - DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 ); + lock( *locks[i] __cfaabi_dbg_ctx2 ); } } @@ -744,5 +754,5 @@ for( __lock_size_t i = 0; i < count; i++ ) { __spinlock_t * l = &source[i]->lock; - DO_LOCK( *l __cfaabi_dbg_ctx2 ); + lock( *l __cfaabi_dbg_ctx2 ); if(locks) locks[i] = l; } Index: src/libcfa/concurrency/preemption.c =================================================================== --- src/libcfa/concurrency/preemption.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/concurrency/preemption.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -10,25 +10,20 @@ // Created On : Mon Jun 5 14:20:42 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jul 21 22:36:05 2017 -// Update Count : 2 +// Last Modified On : Tue Jan 23 17:59:30 2018 +// Update Count : 7 // #include "preemption.h" +#define ftype `ftype` extern "C" { #include -#include -#define __USE_GNU -#include -#undef __USE_GNU #include #include #include } - - -#ifdef __USE_STREAM__ -#include "fstream" -#endif +#undef ftype + +#include "bits/signal.h" //TODO move to defaults @@ -39,8 +34,4 @@ return __CFA_DEFAULT_PREEMPTION__; } - -// Short hands for signal context information -#define __CFA_SIGCXT__ ucontext_t * -#define __CFA_SIGPARMS__ __attribute__((unused)) int sig, __attribute__((unused)) siginfo_t *sfp, __attribute__((unused)) __CFA_SIGCXT__ cxt // FwdDeclarations : timeout handlers @@ -53,15 +44,14 @@ void sigHandler_abort ( __CFA_SIGPARMS__ ); -// FwdDeclarations : sigaction wrapper -static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ); - // FwdDeclarations : alarm thread main void * alarm_loop( __attribute__((unused)) void * args ); // Machine specific register name -#ifdef __x86_64__ +#if defined(__x86_64__) #define CFA_REG_IP REG_RIP -#else +#elif defined(__i386__) #define CFA_REG_IP REG_EIP +#elif defined(__ARM_ARCH__) +#define CFA_REG_IP REG_R15 #endif @@ -179,5 +169,5 @@ void enable_interrupts_noPoll() { __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST ); - verify( prev != 0u ); // If this triggers someone is enabled already enabled interrupts + verifyf( prev != 0u, "Incremented from %u\n", prev ); // If this triggers someone is enabled already enabled interrupts } } @@ -243,6 +233,4 @@ // Setup proper signal handlers __kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // CtxSwitch handler - // __kernel_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO ); // Failure handler - // __kernel_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO ); // Failure handler signal_block( SIGALRM ); @@ -296,8 +284,14 @@ // Receives SIGUSR1 signal and causes the current thread to yield void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) { +#if defined( __ARM_ARCH ) + __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.arm_pc); ) +#else __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); ) - - // Check if it is safe to preempt here +#endif + + // Check if it is safe to preempt here if( !preemption_ready() ) { return; } + + __cfaabi_dbg_print_buffer_decl(" KERNEL: preempting core %p (%p).\n", this_processor, this_thread); preemption_in_progress = true; // Sync flag : prevent recursive calls to the signal handler @@ -371,133 +365,4 @@ } -// Sigaction wrapper : register an signal handler -static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ) { - struct sigaction act; - - act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler; - act.sa_flags = flags; - - if ( sigaction( sig, &act, NULL ) == -1 ) { - __cfaabi_dbg_print_buffer_decl( - " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n", - sig, handler, flags, errno, strerror( errno ) - ); - _exit( EXIT_FAILURE ); - } -} - -// Sigaction wrapper : restore default handler -static void __kernel_sigdefault( int sig ) { - struct sigaction act; - - act.sa_handler = SIG_DFL; - act.sa_flags = 0; - sigemptyset( &act.sa_mask ); - - if ( sigaction( sig, &act, NULL ) == -1 ) { - __cfaabi_dbg_print_buffer_decl( - " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n", - sig, errno, strerror( errno ) - ); - _exit( EXIT_FAILURE ); - } -} - -//============================================================================================= -// Terminating Signals logic -//============================================================================================= - -__cfaabi_dbg_debug_do( - static void __kernel_backtrace( int start ) { - // skip first N stack frames - - enum { Frames = 50 }; - void * array[Frames]; - int size = backtrace( array, Frames ); - char ** messages = backtrace_symbols( array, size ); - - // find executable name - *index( messages[0], '(' ) = '\0'; - #ifdef __USE_STREAM__ - serr | "Stack back trace for:" | messages[0] | endl; - #else - fprintf( stderr, "Stack back trace for: %s\n", messages[0]); - #endif - - // skip last 2 stack frames after main - for ( int i = start; i < size && messages != NULL; i += 1 ) { - char * name = NULL; - char * offset_begin = NULL; - char * offset_end = NULL; - - for ( char *p = messages[i]; *p; ++p ) { - // find parantheses and +offset - if ( *p == '(' ) { - name = p; - } - else if ( *p == '+' ) { - offset_begin = p; - } - else if ( *p == ')' ) { - offset_end = p; - break; - } - } - - // if line contains symbol print it - int frameNo = i - start; - if ( name && offset_begin && offset_end && name < offset_begin ) { - // delimit strings - *name++ = '\0'; - *offset_begin++ = '\0'; - *offset_end++ = '\0'; - - #ifdef __USE_STREAM__ - serr | "(" | frameNo | ")" | messages[i] | ":" - | name | "+" | offset_begin | offset_end | endl; - #else - fprintf( stderr, "(%i) %s : %s + %s %s\n", frameNo, messages[i], name, offset_begin, offset_end); - #endif - } - // otherwise, print the whole line - else { - #ifdef __USE_STREAM__ - serr | "(" | frameNo | ")" | messages[i] | endl; - #else - fprintf( stderr, "(%i) %s\n", frameNo, messages[i] ); - #endif - } - } - - free( messages ); - } -) - -// void sigHandler_segv( __CFA_SIGPARMS__ ) { -// __cfaabi_dbg_debug_do( -// #ifdef __USE_STREAM__ -// serr | "*CFA runtime error* program cfa-cpp terminated with" -// | (sig == SIGSEGV ? "segment fault." : "bus error.") -// | endl; -// #else -// fprintf( stderr, "*CFA runtime error* program cfa-cpp terminated with %s\n", sig == SIGSEGV ? "segment fault." : "bus error." ); -// #endif - -// // skip first 2 stack frames -// __kernel_backtrace( 1 ); -// ) -// exit( EXIT_FAILURE ); -// } - -// void sigHandler_abort( __CFA_SIGPARMS__ ) { -// // skip first 6 stack frames -// __cfaabi_dbg_debug_do( __kernel_backtrace( 6 ); ) - -// // reset default signal handler -// __kernel_sigdefault( SIGABRT ); - -// raise( SIGABRT ); -// } - // Local Variables: // // mode: c // Index: src/libcfa/concurrency/thread.c =================================================================== --- src/libcfa/concurrency/thread.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/concurrency/thread.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -38,4 +38,9 @@ self_mon_p = &self_mon; next = NULL; + __cfaabi_dbg_debug_do( + dbg_next = NULL; + dbg_prev = NULL; + __cfaabi_dbg_thread_register(&this); + ) monitors{ &self_mon_p, 1, (fptr_t)0 }; Index: src/libcfa/interpose.c =================================================================== --- src/libcfa/interpose.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/interpose.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -22,11 +22,16 @@ #include #include +#define __USE_GNU +#include +#undef __USE_GNU +#include } #include "bits/debug.h" #include "bits/defs.h" +#include "bits/signal.h" #include "startup.h" -void interpose_startup(void) __attribute__(( constructor( STARTUP_PRIORITY_CORE ) )); +void __cfaabi_interpose_startup(void) __attribute__(( constructor( STARTUP_PRIORITY_CORE ) )); typedef void (*generic_fptr_t)(void); @@ -84,10 +89,21 @@ #define INIT_REALRTN( x, ver ) assign_ptr( (void**)&libc_##x, #x, ver) -void interpose_startup() { +void sigHandler_segv ( __CFA_SIGPARMS__ ); +void sigHandler_abort( __CFA_SIGPARMS__ ); + +void __cfaabi_interpose_startup() { const char *version = NULL; INIT_REALRTN( abort, version ); INIT_REALRTN( exit, version ); -} + + __kernel_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO ); // Failure handler + __kernel_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO ); // Failure handler + __kernel_sigaction( SIGABRT, sigHandler_abort, SA_SIGINFO ); // Failure handler +} + +//============================================================================================= +// Terminating Signals logic +//============================================================================================= extern "C" { @@ -137,4 +153,71 @@ libc_abort(); } +} + +// skip first 6 stack frames by default +static void __kernel_backtrace() { + // skip first N stack frames + int start = 6; + + enum { Frames = 50 }; + void * array[Frames]; + int size = backtrace( array, Frames ); + char ** messages = backtrace_symbols( array, size ); + + // find executable name + *index( messages[0], '(' ) = '\0'; + __cfaabi_dbg_bits_print_nolock( "Stack back trace for: %s\n", messages[0]); + + // skip last 2 stack frames after main + for ( int i = start; i < size && messages != NULL; i += 1 ) { + char * name = NULL; + char * offset_begin = NULL; + char * offset_end = NULL; + + for ( char *p = messages[i]; *p; ++p ) { + // find parantheses and +offset + if ( *p == '(' ) { + name = p; + } + else if ( *p == '+' ) { + offset_begin = p; + } + else if ( *p == ')' ) { + offset_end = p; + break; + } + } + + // if line contains symbol print it + int frameNo = i - start; + if ( name && offset_begin && offset_end && name < offset_begin ) { + // delimit strings + *name++ = '\0'; + *offset_begin++ = '\0'; + *offset_end++ = '\0'; + + __cfaabi_dbg_bits_print_nolock( "(%i) %s : %s + %s %s\n", frameNo, messages[i], name, offset_begin, offset_end); + } + // otherwise, print the whole line + else { + __cfaabi_dbg_bits_print_nolock( "(%i) %s\n", frameNo, messages[i] ); + } + } + + free( messages ); +} + +void sigHandler_segv( __CFA_SIGPARMS__ ) { + // skip first only 1 stack frames in case of segfault. + abortf( "*CFA runtime error* program cfa-cpp terminated with %s\n", sig == SIGSEGV ? "segment fault." : "bus error." ); +} + +void sigHandler_abort( __CFA_SIGPARMS__ ) { + __kernel_backtrace(); + + // reset default signal handler + __kernel_sigdefault( SIGABRT ); + + raise( SIGABRT ); } Index: src/libcfa/iostream =================================================================== --- src/libcfa/iostream (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/iostream (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Dec 21 13:55:41 2017 -// Update Count : 145 +// Last Modified On : Thu Jan 25 13:08:39 2018 +// Update Count : 149 // @@ -124,4 +124,6 @@ }; // readable +forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, _Bool & ); + forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, char & ); forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, signed char & ); @@ -145,4 +147,8 @@ forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long double _Complex & ); +// manipulators +forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, istype & (*)( istype & ) ); +forall( dtype istype | istream( istype ) ) istype & endl( istype & is ); + struct _Istream_cstrUC { char * s; }; _Istream_cstrUC cstr( char * ); Index: src/libcfa/iostream.c =================================================================== --- src/libcfa/iostream.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/iostream.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Dec 21 13:55:09 2017 -// Update Count : 427 +// Last Modified On : Thu Jan 25 13:09:28 2018 +// Update Count : 467 // @@ -19,5 +19,7 @@ #include #include // true/false -#include // strlen +//#include // strlen, strcmp +extern int strcmp (const char *__s1, const char *__s2) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); #include // DBL_DIG, LDBL_DIG #include // creal, cimag @@ -301,4 +303,17 @@ forall( dtype istype | istream( istype ) ) +istype & ?|?( istype & is, _Bool & b ) { + char val[6]; + fmt( is, "%5s", val ); + if ( strcmp( val, "true" ) == 0 ) b = true; + else if ( strcmp( val, "false" ) == 0 ) b = false; + else { + fprintf( stderr, "invalid _Bool constant\n" ); + abort(); + } // if + return is; +} // ?|? + +forall( dtype istype | istream( istype ) ) istype & ?|?( istype & is, char & c ) { fmt( is, "%c", &c ); // must pass pointer through varg to fmt @@ -410,4 +425,15 @@ } // ?|? +forall( dtype istype | istream( istype ) ) +istype & ?|?( istype & is, istype & (* manip)( istype & ) ) { + return manip( is ); +} // ?|? + +forall( dtype istype | istream( istype ) ) +istype & endl( istype & is ) { + fmt( is, "%*[ \t\f\n\r\v]" ); // ignore whitespace + return is; +} // endl + _Istream_cstrUC cstr( char * str ) { return (_Istream_cstrUC){ str }; } forall( dtype istype | istream( istype ) ) Index: src/libcfa/stdlib.c =================================================================== --- src/libcfa/stdlib.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/libcfa/stdlib.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// algorithm.c -- +// stdlib.c -- // // Author : Peter A. Buhr // Created On : Thu Jan 28 17:10:29 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jan 2 12:20:32 2018 -// Update Count : 441 +// Last Modified On : Wed Jan 3 08:29:29 2018 +// Update Count : 444 // @@ -24,4 +24,6 @@ #include // _Complex_I #include + +//--------------------------------------- // resize, non-array types @@ -257,5 +259,5 @@ //--------------------------------------- -extern "C" { void srandom( unsigned int seed ) { srand48( seed ); } } // override C version +extern "C" { void srandom( unsigned int seed ) { srand48( (long int)seed ); } } // override C version char random( void ) { return (unsigned long int)random(); } char random( char u ) { return random( (unsigned long int)u ); } Index: src/prelude/prelude.cf =================================================================== --- src/prelude/prelude.cf (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/prelude/prelude.cf (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -39,6 +39,4 @@ // ------------------------------------------------------------ -_Bool ?++( _Bool & ), ?++( volatile _Bool & ); -_Bool ?--( _Bool & ), ?--( volatile _Bool & ); signed short ?++( signed short & ), ?++( volatile signed short & ); signed short ?--( signed short & ), ?--( volatile signed short & ); @@ -94,5 +92,4 @@ // ------------------------------------------------------------ -_Bool ++?( _Bool & ), --?( _Bool & ); signed short ++?( signed short & ), --?( signed short & ); signed int ++?( signed int & ), --?( signed int & ); @@ -125,5 +122,5 @@ forall( ftype FT ) FT & *?( FT * ); -_Bool +?( _Bool ), -?( _Bool ), ~?( _Bool ); +_Bool +?( _Bool ), -?( _Bool ); signed int +?( signed int ), -?( signed int ), ~?( signed int ); unsigned int +?( unsigned int ), -?( unsigned int ), ~?( unsigned int ); @@ -157,5 +154,4 @@ // ------------------------------------------------------------ -_Bool ?*?( _Bool, _Bool ), ?/?( _Bool, _Bool ), ?%?( _Bool, _Bool ); signed int ?*?( signed int, signed int ), ?/?( signed int, signed int ), ?%?( signed int, signed int ); unsigned int ?*?( unsigned int, unsigned int ), ?/?( unsigned int, unsigned int ), ?%?( unsigned int, unsigned int ); @@ -215,5 +211,4 @@ // ------------------------------------------------------------ -_Bool ?<>?( _Bool, _Bool ); signed int ?<>?( signed int, signed int ); unsigned int ?<>?( unsigned int, unsigned int ); @@ -467,5 +462,4 @@ -_Bool ?*=?( _Bool &, _Bool ), ?*=?( volatile _Bool &, _Bool ); char ?*=?( char &, char ), ?*=?( volatile char &, char ); char signed ?*=?( char signed &, char signed ), ?*=?( volatile char signed &, char signed ); @@ -534,5 +528,4 @@ 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 ); @@ -547,5 +540,4 @@ 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 ); Index: src/tests/.expect/alloc-ERROR.txt =================================================================== --- src/tests/.expect/alloc-ERROR.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/.expect/alloc-ERROR.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -1,3 +1,23 @@ alloc.c:264:1 error: No reasonable alternatives for expression Applying untyped: + Name: ?=? +...to: + Name: p + Applying untyped: + Name: realloc + ...to: + Name: stp + Applying untyped: + Name: ?*? + ...to: + Name: dim + Sizeof Expression on: Applying untyped: + Name: *? + ...to: + Name: stp + + + + +alloc.c:265:1 error: No reasonable alternatives for expression Applying untyped: Name: ?=? ...to: @@ -19,5 +39,5 @@ -alloc.c:265:1 error: No reasonable alternatives for expression Applying untyped: +alloc.c:266:1 error: No reasonable alternatives for expression Applying untyped: Name: ?=? ...to: @@ -30,5 +50,5 @@ -alloc.c:266:1 error: No reasonable alternatives for expression Applying untyped: +alloc.c:267:1 error: No reasonable alternatives for expression Applying untyped: Name: ?=? ...to: Index: src/tests/.expect/alloc.txt =================================================================== --- src/tests/.expect/alloc.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/.expect/alloc.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -60,4 +60,2 @@ pointer arithmetic 0 CFA deep malloc 0xdeadbeef - -SHOULD FAIL Index: src/tests/.expect/ctor-autogen-ERR1.txt =================================================================== --- src/tests/.expect/ctor-autogen-ERR1.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,9 +1,0 @@ -ctor-autogen.c:102:1 error: No reasonable alternatives for expression Applying untyped: - Name: ?{} -...to: - Cast of: - Variable Expression: x: instance of struct Managed with body 1 - ... to: - reference to instance of struct Managed with body 1 - constant expression (123 123: signed int) - Index: src/tests/.expect/ctor-autogen.txt =================================================================== --- src/tests/.expect/ctor-autogen.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,1 +1,0 @@ - Index: src/tests/.expect/dtor-early-exit-ERR1.txt =================================================================== --- src/tests/.expect/dtor-early-exit-ERR1.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,4 +1,0 @@ -dtor-early-exit.c:153:1 error: jump to label 'L1' crosses initialization of y Branch (Goto) - with target: L1 - with original target: L1 - Index: src/tests/.expect/dtor-early-exit-ERR2.txt =================================================================== --- src/tests/.expect/dtor-early-exit-ERR2.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,4 +1,0 @@ -dtor-early-exit.c:220:1 error: jump to label 'L2' crosses initialization of y Branch (Goto) - with target: L2 - with original target: L2 - Index: src/tests/.expect/dtor-early-exit.txt =================================================================== --- src/tests/.expect/dtor-early-exit.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,220 +1,0 @@ -f i=0 -construct x -construct y -construct z -destruct z -destruct y -destruct x -f i=1 -construct x -construct y -construct z -destruct z -destruct y -destruct x -f i=2 -construct x -construct y -construct z -destruct z -destruct y -destruct x -f i=3 -construct x -construct y -construct z -destruct z -destruct y -destruct x - -g for i=0 -construct x -destruct x -g for i=1 -construct x -destruct x -g for i=2 -construct x -destruct x -g for i=3 -construct x -destruct x -g for i=4 -construct x -destruct x -g for i=5 -construct x -destruct x -g for i=6 -construct x -destruct x -g for i=7 -construct x -destruct x -g for i=8 -construct x -destruct x -g for i=9 -construct x -destruct x - -g while i=0 -construct x -destruct x -g while i=1 -construct x -destruct x -g while i=2 -construct x -destruct x -g while i=3 -construct x -destruct x -g while i=4 -construct x -destruct x -g while i=5 -construct x -destruct x -g while i=6 -construct x -destruct x -g while i=7 -construct x -destruct x -g while i=8 -construct x -destruct x -g while i=9 -construct x -destruct x - -construct y -g switch i=0 -destruct y -construct y -g switch i=1 -destruct y -construct y -g switch i=2 -destruct y -construct y -g switch i=3 -destruct y -construct y -g switch i=4 -destruct y -construct y -g switch i=5 -destruct y -construct y -g switch i=6 -destruct y -construct y -g switch i=7 -destruct y -construct y -g switch i=8 -destruct y -construct y -g switch i=9 -destruct y - -g for k=0 -g for i=0 -construct x -g for j=0 -construct y -continue L2 -destruct y -g for j=1 -construct y -break L2 -destruct y -destruct x -g for i=1 -construct x -g for j=0 -construct y -continue L2 -destruct y -g for j=1 -construct y -break L2 -destruct y -destruct x -g for i=2 -construct x -continue L1 -destruct x -g for i=3 -construct x -break L1 -destruct x -g for k=1 -g for i=0 -construct x -g for j=0 -construct y -continue L2 -destruct y -g for j=1 -construct y -break L2 -destruct y -destruct x -g for i=1 -construct x -g for j=0 -construct y -continue L2 -destruct y -g for j=1 -construct y -break L2 -destruct y -destruct x -g for i=2 -construct x -continue L1 -destruct x -g for i=3 -construct x -break L1 -destruct x - -construct w -construct v -break L3 -destruct v -destruct w - -h -construct y -L1 -construct x -L2 -goto L1 -destruct x -L1 -construct x -L2 -goto L2 -L2 -goto L3 -L3 -goto L2-2 -L2 -goto L4 -destruct x -destruct y -L4 -goto L0 -construct y -L1 -construct x -L2 -goto L4 -destruct x -destruct y -L4 Index: src/tests/.expect/globals.txt =================================================================== --- src/tests/.expect/globals.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,9 +1,0 @@ -static inline autogen value -no no no 22 -no no yes 22 -no yes no 22 -no yes yes 22 -yes no no 22 -yes no yes 22 -yes yes no 22 -yes yes yes 22 Index: src/tests/.expect/io.txt =================================================================== --- src/tests/.expect/io.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/.expect/io.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -27,4 +27,5 @@ output basic types +false A 23 93 1 2 3 4 5 6 7 8 Index: src/tests/.expect/libcfa_vector.txt =================================================================== --- src/tests/.expect/libcfa_vector.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,5 +1,0 @@ -0 -1 -2 -3 -0 Index: src/tests/.expect/literals.x64.txt =================================================================== --- src/tests/.expect/literals.x64.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/.expect/literals.x64.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -35,21 +35,24 @@ void __write__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object992)(), void *__anonymous_object993), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object994)(), void *__anonymous_object995, void *__anonymous_object996), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object997)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object998), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object999)(), void *__anonymous_object1000, void *__anonymous_object1001), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1002)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1003, void *__anonymous_object1004), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1005)(), void *__anonymous_object1006, void *__anonymous_object1007), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1008)(), void *__anonymous_object1009, void *__anonymous_object1010), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1011)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1012, void *__anonymous_object1013), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1014, void *__anonymous_object1015), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1016), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1017, void *__anonymous_object1018), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1019), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1020, void *__anonymous_object1021), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1022), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1023), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1024, _Bool __anonymous_object1025), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1026), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1027, const char *__anonymous_object1028), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1029), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1030, _Bool __anonymous_object1031), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1032), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1033), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1034), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1035), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1036), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1037, const char *__anonymous_object1038), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1039), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1040, const char *__anonymous_object1041), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1042), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1043), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1044, const char *__anonymous_object1045, unsigned long int __anonymous_object1046), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1047, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1048, void *__anonymous_object1049), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1050), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1051, void *__anonymous_object1052), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1053), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1054), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1055), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1056, void *__anonymous_object1057), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1058, void *__anonymous_object1059), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1060), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1); void __write_reverse__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object1061)(), void *__anonymous_object1062), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object1063)(), void *__anonymous_object1064, void *__anonymous_object1065), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object1066)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object1067), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object1068)(), void *__anonymous_object1069, void *__anonymous_object1070), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1071)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1072, void *__anonymous_object1073), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1074)(), void *__anonymous_object1075, void *__anonymous_object1076), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1077)(), void *__anonymous_object1078, void *__anonymous_object1079), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1080)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1081, void *__anonymous_object1082), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1083, void *__anonymous_object1084), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1085), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1086, void *__anonymous_object1087), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1088), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1089, void *__anonymous_object1090), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1091), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1092), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1093, _Bool __anonymous_object1094), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1095), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1096, const char *__anonymous_object1097), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1098), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1099, _Bool __anonymous_object1100), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1101), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1102), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1103), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1104), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1105), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1106, const char *__anonymous_object1107), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1108), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1109, const char *__anonymous_object1110), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1111), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1112), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1113, const char *__anonymous_object1114, unsigned long int __anonymous_object1115), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1116, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1117, void *__anonymous_object1118), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1119), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1120, void *__anonymous_object1121), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1122), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1123), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1124), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1125, void *__anonymous_object1126), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1127, void *__anonymous_object1128), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1129), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1130), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1131), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1132, char *__anonymous_object1133, unsigned long int __anonymous_object1134), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1135, char __anonymous_object1136), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1137, const char *__fmt__PCc_1, ...), void *__anonymous_object1138, char *__anonymous_object1139); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1140), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1141), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1142, char *__anonymous_object1143, unsigned long int __anonymous_object1144), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1145, char __anonymous_object1146), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1147, const char *__fmt__PCc_1, ...), void *__anonymous_object1148, signed char *__anonymous_object1149); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1150), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1151), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1152, char *__anonymous_object1153, unsigned long int __anonymous_object1154), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1155, char __anonymous_object1156), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1157, const char *__fmt__PCc_1, ...), void *__anonymous_object1158, unsigned char *__anonymous_object1159); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1160), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1161), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1162, char *__anonymous_object1163, unsigned long int __anonymous_object1164), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1165, char __anonymous_object1166), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1167, const char *__fmt__PCc_1, ...), void *__anonymous_object1168, signed short int *__anonymous_object1169); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1170), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1171), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1172, char *__anonymous_object1173, unsigned long int __anonymous_object1174), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1175, char __anonymous_object1176), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1177, const char *__fmt__PCc_1, ...), void *__anonymous_object1178, unsigned short int *__anonymous_object1179); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Ri__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1180), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1181), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1182, char *__anonymous_object1183, unsigned long int __anonymous_object1184), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1185, char __anonymous_object1186), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1187, const char *__fmt__PCc_1, ...), void *__anonymous_object1188, signed int *__anonymous_object1189); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUi__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1190), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1191), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1192, char *__anonymous_object1193, unsigned long int __anonymous_object1194), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1195, char __anonymous_object1196), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1197, const char *__fmt__PCc_1, ...), void *__anonymous_object1198, unsigned int *__anonymous_object1199); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1200), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1201), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1202, char *__anonymous_object1203, unsigned long int __anonymous_object1204), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1205, char __anonymous_object1206), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1207, const char *__fmt__PCc_1, ...), void *__anonymous_object1208, signed long int *__anonymous_object1209); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1210), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1211), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1212, char *__anonymous_object1213, unsigned long int __anonymous_object1214), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1215, char __anonymous_object1216), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1217, const char *__fmt__PCc_1, ...), void *__anonymous_object1218, signed long long int *__anonymous_object1219); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1220), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1221), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1222, char *__anonymous_object1223, unsigned long int __anonymous_object1224), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1225, char __anonymous_object1226), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1227, const char *__fmt__PCc_1, ...), void *__anonymous_object1228, unsigned long int *__anonymous_object1229); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1230), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1231), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1232, char *__anonymous_object1233, unsigned long int __anonymous_object1234), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1235, char __anonymous_object1236), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1237, const char *__fmt__PCc_1, ...), void *__anonymous_object1238, unsigned long long int *__anonymous_object1239); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1240), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1241), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1242, char *__anonymous_object1243, unsigned long int __anonymous_object1244), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1245, char __anonymous_object1246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1247, const char *__fmt__PCc_1, ...), void *__anonymous_object1248, float *__anonymous_object1249); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1250), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1251), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1252, char *__anonymous_object1253, unsigned long int __anonymous_object1254), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1255, char __anonymous_object1256), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1257, const char *__fmt__PCc_1, ...), void *__anonymous_object1258, double *__anonymous_object1259); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1260), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1261), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1262, char *__anonymous_object1263, unsigned long int __anonymous_object1264), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1265, char __anonymous_object1266), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1267, const char *__fmt__PCc_1, ...), void *__anonymous_object1268, long double *__anonymous_object1269); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1270), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1271), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1272, char *__anonymous_object1273, unsigned long int __anonymous_object1274), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1275, char __anonymous_object1276), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1277, const char *__fmt__PCc_1, ...), void *__anonymous_object1278, float _Complex *__anonymous_object1279); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1280), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1281), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1282, char *__anonymous_object1283, unsigned long int __anonymous_object1284), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1285, char __anonymous_object1286), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1287, const char *__fmt__PCc_1, ...), void *__anonymous_object1288, double _Complex *__anonymous_object1289); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1290), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1291), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1292, char *__anonymous_object1293, unsigned long int __anonymous_object1294), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1295, char __anonymous_object1296), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1297, const char *__fmt__PCc_1, ...), void *__anonymous_object1298, long double _Complex *__anonymous_object1299); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rb__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1130), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1131), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1132, char *__anonymous_object1133, unsigned long int __anonymous_object1134), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1135, char __anonymous_object1136), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1137, const char *__fmt__PCc_1, ...), void *__anonymous_object1138, _Bool *__anonymous_object1139); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1140), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1141), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1142, char *__anonymous_object1143, unsigned long int __anonymous_object1144), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1145, char __anonymous_object1146), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1147, const char *__fmt__PCc_1, ...), void *__anonymous_object1148, char *__anonymous_object1149); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1150), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1151), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1152, char *__anonymous_object1153, unsigned long int __anonymous_object1154), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1155, char __anonymous_object1156), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1157, const char *__fmt__PCc_1, ...), void *__anonymous_object1158, signed char *__anonymous_object1159); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1160), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1161), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1162, char *__anonymous_object1163, unsigned long int __anonymous_object1164), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1165, char __anonymous_object1166), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1167, const char *__fmt__PCc_1, ...), void *__anonymous_object1168, unsigned char *__anonymous_object1169); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1170), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1171), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1172, char *__anonymous_object1173, unsigned long int __anonymous_object1174), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1175, char __anonymous_object1176), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1177, const char *__fmt__PCc_1, ...), void *__anonymous_object1178, signed short int *__anonymous_object1179); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1180), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1181), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1182, char *__anonymous_object1183, unsigned long int __anonymous_object1184), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1185, char __anonymous_object1186), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1187, const char *__fmt__PCc_1, ...), void *__anonymous_object1188, unsigned short int *__anonymous_object1189); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Ri__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1190), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1191), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1192, char *__anonymous_object1193, unsigned long int __anonymous_object1194), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1195, char __anonymous_object1196), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1197, const char *__fmt__PCc_1, ...), void *__anonymous_object1198, signed int *__anonymous_object1199); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUi__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1200), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1201), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1202, char *__anonymous_object1203, unsigned long int __anonymous_object1204), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1205, char __anonymous_object1206), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1207, const char *__fmt__PCc_1, ...), void *__anonymous_object1208, unsigned int *__anonymous_object1209); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1210), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1211), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1212, char *__anonymous_object1213, unsigned long int __anonymous_object1214), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1215, char __anonymous_object1216), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1217, const char *__fmt__PCc_1, ...), void *__anonymous_object1218, signed long int *__anonymous_object1219); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1220), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1221), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1222, char *__anonymous_object1223, unsigned long int __anonymous_object1224), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1225, char __anonymous_object1226), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1227, const char *__fmt__PCc_1, ...), void *__anonymous_object1228, signed long long int *__anonymous_object1229); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1230), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1231), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1232, char *__anonymous_object1233, unsigned long int __anonymous_object1234), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1235, char __anonymous_object1236), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1237, const char *__fmt__PCc_1, ...), void *__anonymous_object1238, unsigned long int *__anonymous_object1239); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1240), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1241), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1242, char *__anonymous_object1243, unsigned long int __anonymous_object1244), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1245, char __anonymous_object1246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1247, const char *__fmt__PCc_1, ...), void *__anonymous_object1248, unsigned long long int *__anonymous_object1249); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1250), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1251), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1252, char *__anonymous_object1253, unsigned long int __anonymous_object1254), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1255, char __anonymous_object1256), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1257, const char *__fmt__PCc_1, ...), void *__anonymous_object1258, float *__anonymous_object1259); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1260), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1261), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1262, char *__anonymous_object1263, unsigned long int __anonymous_object1264), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1265, char __anonymous_object1266), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1267, const char *__fmt__PCc_1, ...), void *__anonymous_object1268, double *__anonymous_object1269); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1270), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1271), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1272, char *__anonymous_object1273, unsigned long int __anonymous_object1274), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1275, char __anonymous_object1276), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1277, const char *__fmt__PCc_1, ...), void *__anonymous_object1278, long double *__anonymous_object1279); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1280), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1281), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1282, char *__anonymous_object1283, unsigned long int __anonymous_object1284), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1285, char __anonymous_object1286), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1287, const char *__fmt__PCc_1, ...), void *__anonymous_object1288, float _Complex *__anonymous_object1289); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1290), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1291), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1292, char *__anonymous_object1293, unsigned long int __anonymous_object1294), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1295, char __anonymous_object1296), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1297, const char *__fmt__PCc_1, ...), void *__anonymous_object1298, double _Complex *__anonymous_object1299); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1300), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1301), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1302, char *__anonymous_object1303, unsigned long int __anonymous_object1304), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1305, char __anonymous_object1306), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1307, const char *__fmt__PCc_1, ...), void *__anonymous_object1308, long double _Complex *__anonymous_object1309); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1310), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1311), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1312, char *__anonymous_object1313, unsigned long int __anonymous_object1314), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1315, char __anonymous_object1316), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1317, const char *__fmt__PCc_1, ...), void *__anonymous_object1318, void *(*__anonymous_object1319)(void *__anonymous_object1320)); +void *__endl__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1321), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1322), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1323, char *__anonymous_object1324, unsigned long int __anonymous_object1325), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1326, char __anonymous_object1327), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1328, const char *__fmt__PCc_1, ...), void *__is__R7tistype_1); struct _Istream_cstrUC { char *__s__Pc_1; @@ -78,6 +81,6 @@ ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=__s__Pc_1) /* ?{} */); } -struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1300); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1301), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1302), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1303, char *__anonymous_object1304, unsigned long int __anonymous_object1305), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1306, char __anonymous_object1307), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1308, const char *__fmt__PCc_1, ...), void *__anonymous_object1309, struct _Istream_cstrUC __anonymous_object1310); +struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1329); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1330), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1331), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1332, char *__anonymous_object1333, unsigned long int __anonymous_object1334), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1335, char __anonymous_object1336), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1337, const char *__fmt__PCc_1, ...), void *__anonymous_object1338, struct _Istream_cstrUC __anonymous_object1339); struct _Istream_cstrC { char *__s__Pc_1; @@ -117,6 +120,6 @@ ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=__size__i_1) /* ?{} */); } -struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1311, signed int __size__i_1); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1312), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1313), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1314, char *__anonymous_object1315, unsigned long int __anonymous_object1316), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1317, char __anonymous_object1318), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1319, const char *__fmt__PCc_1, ...), void *__anonymous_object1320, struct _Istream_cstrC __anonymous_object1321); +struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1340, signed int __size__i_1); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1341), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1342), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1343, char *__anonymous_object1344, unsigned long int __anonymous_object1345), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1346, char __anonymous_object1347), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1348, const char *__fmt__PCc_1, ...), void *__anonymous_object1349, struct _Istream_cstrC __anonymous_object1350); enum __anonymous0 { __sepSize__C13e__anonymous0_1 = 16, @@ -398,26 +401,26 @@ } -_Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1322); -void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1323); -void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1324, _Bool __anonymous_object1325); -const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1326); -void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1327, const char *__anonymous_object1328); -_Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1329); -void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1330, _Bool __anonymous_object1331); -void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1332); -void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1333); -_Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1334); -_Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1335); -const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1336); -void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1337, const char *__anonymous_object1338); -const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1339); -void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1340, const char *__anonymous_object1341); -signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1342); -signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1343); -void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1344, const char *__name__PCc_1, const char *__mode__PCc_1); -void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1345, const char *__name__PCc_1); -void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1346); -struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1347, const char *__data__PCc_1, unsigned long int __size__Ul_1); -signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1348, const char *__fmt__PCc_1, ...); +_Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1351); +void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1352); +void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1353, _Bool __anonymous_object1354); +const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1355); +void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1356, const char *__anonymous_object1357); +_Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1358); +void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1359, _Bool __anonymous_object1360); +void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1361); +void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1362); +_Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1363); +_Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1364); +const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1365); +void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1366, const char *__anonymous_object1367); +const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1368); +void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1369, const char *__anonymous_object1370); +signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1371); +signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1372); +void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1373, const char *__name__PCc_1, const char *__mode__PCc_1); +void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1374, const char *__name__PCc_1); +void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1375); +struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1376, const char *__data__PCc_1, unsigned long int __size__Ul_1); +signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1377, const char *__fmt__PCc_1, ...); void ___constructor__F_R9sofstream__1(struct ofstream *__os__R9sofstream_1); void ___constructor__F_R9sofstreamPCcPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1); @@ -458,5 +461,5 @@ struct ifstream *__read__FR9sifstream_R9sifstreamPcUl__1(struct ifstream *__is__R9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1); struct ifstream *__ungetc__FR9sifstream_R9sifstreamc__1(struct ifstream *__is__R9sifstream_1, char __c__c_1); -signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1349, const char *__fmt__PCc_1, ...); +signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1378, const char *__fmt__PCc_1, ...); void ___constructor__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1); void ___constructor__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1); @@ -468,7 +471,7 @@ struct ofstream *_tmp_cp_ret2; __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1350))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1351))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1352, _Bool __anonymous_object1353))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1354))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1355, const char *__anonymous_object1356))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1357))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1358, _Bool __anonymous_object1359))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1360))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1361))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1362))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1363))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1364))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1365, const char *__anonymous_object1366))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1367))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1368, const char *__anonymous_object1369))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1370))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1371))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1372, const char *__anonymous_object1373, unsigned long int __anonymous_object1374))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1375, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret2=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1376))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1377))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1378, _Bool __anonymous_object1379))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1380))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1381, const char *__anonymous_object1382))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1383))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1384, _Bool __anonymous_object1385))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1386))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1387))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1388))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1389))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1390))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1391, const char *__anonymous_object1392))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1393))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1394, const char *__anonymous_object1395))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1396))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1397))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1398, const char *__anonymous_object1399, unsigned long int __anonymous_object1400))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1401, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret1=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(((_Bool (*)(void *__anonymous_object1402))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1403))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1404, _Bool __anonymous_object1405))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1406))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1407, const char *__anonymous_object1408))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1409))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1410, _Bool __anonymous_object1411))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1412))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1413))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1414))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1415))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1416))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1417, const char *__anonymous_object1418))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1419))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1420, const char *__anonymous_object1421))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1422))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1423))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1424, const char *__anonymous_object1425, unsigned long int __anonymous_object1426))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1427, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret0=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1428))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1429))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1430, _Bool __anonymous_object1431))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1432))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1433, const char *__anonymous_object1434))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1435))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1436, _Bool __anonymous_object1437))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1438))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1439))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1441))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1442))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1443, const char *__anonymous_object1444))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1445))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1446, const char *__anonymous_object1447))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1448))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1449))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1450, const char *__anonymous_object1451, unsigned long int __anonymous_object1452))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1453, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret0)), __v__c_1)))) , _tmp_cp_ret1)), ((void *(*)(void *__anonymous_object1454))(&_thunk0)))))) , _tmp_cp_ret2)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1379))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1380))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1381, _Bool __anonymous_object1382))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1383))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1384, const char *__anonymous_object1385))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1386))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1387, _Bool __anonymous_object1388))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1389))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1390))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1391))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1392))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1393))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1394, const char *__anonymous_object1395))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1396))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1397, const char *__anonymous_object1398))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1399))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1400))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1401, const char *__anonymous_object1402, unsigned long int __anonymous_object1403))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1404, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret2=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1405))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1406))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1407, _Bool __anonymous_object1408))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1409))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1410, const char *__anonymous_object1411))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1412))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1413, _Bool __anonymous_object1414))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1415))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1416))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1417))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1418))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1419))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1420, const char *__anonymous_object1421))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1422))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1423, const char *__anonymous_object1424))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1425))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1426))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1427, const char *__anonymous_object1428, unsigned long int __anonymous_object1429))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1430, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret1=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(((_Bool (*)(void *__anonymous_object1431))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1432))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1433, _Bool __anonymous_object1434))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1435))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1436, const char *__anonymous_object1437))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1438))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1439, _Bool __anonymous_object1440))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1441))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1442))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1443))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1444))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1445))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1446, const char *__anonymous_object1447))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1448))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1449, const char *__anonymous_object1450))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1451))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1452))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1453, const char *__anonymous_object1454, unsigned long int __anonymous_object1455))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1456, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret0=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1457))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1458))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1459, _Bool __anonymous_object1460))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1461))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1462, const char *__anonymous_object1463))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1464))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1465, _Bool __anonymous_object1466))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1467))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1468))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1469))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1470))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1471))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1472, const char *__anonymous_object1473))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1474))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1475, const char *__anonymous_object1476))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1477))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1478))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1479, const char *__anonymous_object1480, unsigned long int __anonymous_object1481))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1482, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret0)), __v__c_1)))) , _tmp_cp_ret1)), ((void *(*)(void *__anonymous_object1483))(&_thunk0)))))) , _tmp_cp_ret2)); } void __f__F_Sc__1(signed char __v__Sc_1){ @@ -477,7 +480,7 @@ struct ofstream *_tmp_cp_ret5; __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1455))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1456))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1457, _Bool __anonymous_object1458))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1459))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1460, const char *__anonymous_object1461))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1462))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1463, _Bool __anonymous_object1464))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1465))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1466))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1467))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1468))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1469))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1470, const char *__anonymous_object1471))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1472))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1473, const char *__anonymous_object1474))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1475))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1476))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1477, const char *__anonymous_object1478, unsigned long int __anonymous_object1479))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1480, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret5=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1481))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1482))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1483, _Bool __anonymous_object1484))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1485))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1486, const char *__anonymous_object1487))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1488))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1489, _Bool __anonymous_object1490))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1491))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1492))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1493))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1494))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1495))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1496, const char *__anonymous_object1497))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1498))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1499, const char *__anonymous_object1500))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1501))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1502))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1503, const char *__anonymous_object1504, unsigned long int __anonymous_object1505))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1506, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret4=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1507))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1508))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1509, _Bool __anonymous_object1510))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1511))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1512, const char *__anonymous_object1513))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1514))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1515, _Bool __anonymous_object1516))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1517))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1518))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1519))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1520))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1521))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1522, const char *__anonymous_object1523))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1524))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1525, const char *__anonymous_object1526))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1527))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1528))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1529, const char *__anonymous_object1530, unsigned long int __anonymous_object1531))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1532, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1533))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1534))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1535, _Bool __anonymous_object1536))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1537))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1538, const char *__anonymous_object1539))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1540))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1541, _Bool __anonymous_object1542))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1543))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1544))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1546))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1547))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1548, const char *__anonymous_object1549))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1550))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1551, const char *__anonymous_object1552))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1553))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1554))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1555, const char *__anonymous_object1556, unsigned long int __anonymous_object1557))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1558, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret3)), __v__Sc_1)))) , _tmp_cp_ret4)), ((void *(*)(void *__anonymous_object1559))(&_thunk1)))))) , _tmp_cp_ret5)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1484))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1485))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1486, _Bool __anonymous_object1487))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1488))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1489, const char *__anonymous_object1490))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1491))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1492, _Bool __anonymous_object1493))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1494))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1495))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1496))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1497))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1498))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1499, const char *__anonymous_object1500))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1501))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1502, const char *__anonymous_object1503))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1504))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1505))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1506, const char *__anonymous_object1507, unsigned long int __anonymous_object1508))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1509, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret5=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1510))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1511))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1512, _Bool __anonymous_object1513))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1514))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1515, const char *__anonymous_object1516))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1517))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1518, _Bool __anonymous_object1519))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1520))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1521))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1522))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1523))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1524))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1525, const char *__anonymous_object1526))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1527))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1528, const char *__anonymous_object1529))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1530))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1531))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1532, const char *__anonymous_object1533, unsigned long int __anonymous_object1534))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1535, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret4=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1536))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1537))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1538, _Bool __anonymous_object1539))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1540))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1541, const char *__anonymous_object1542))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1543))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1544, _Bool __anonymous_object1545))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1546))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1547))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1548))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1549))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1550))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1551, const char *__anonymous_object1552))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1553))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1554, const char *__anonymous_object1555))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1556))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1557))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1558, const char *__anonymous_object1559, unsigned long int __anonymous_object1560))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1561, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1562))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1563))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1564, _Bool __anonymous_object1565))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1566))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1567, const char *__anonymous_object1568))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1569))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1570, _Bool __anonymous_object1571))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1572))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1573))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1574))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1575))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1576))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1577, const char *__anonymous_object1578))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1579))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1580, const char *__anonymous_object1581))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1582))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1583))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1584, const char *__anonymous_object1585, unsigned long int __anonymous_object1586))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1587, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret3)), __v__Sc_1)))) , _tmp_cp_ret4)), ((void *(*)(void *__anonymous_object1588))(&_thunk1)))))) , _tmp_cp_ret5)); } void __f__F_Uc__1(unsigned char __v__Uc_1){ @@ -486,7 +489,7 @@ struct ofstream *_tmp_cp_ret8; __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1560))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1561))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1562, _Bool __anonymous_object1563))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1564))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1565, const char *__anonymous_object1566))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1567))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1568, _Bool __anonymous_object1569))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1570))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1571))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1572))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1573))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1574))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1575, const char *__anonymous_object1576))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1577))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1578, const char *__anonymous_object1579))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1580))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1581))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1582, const char *__anonymous_object1583, unsigned long int __anonymous_object1584))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1585, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret8=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1586))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1587))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1588, _Bool __anonymous_object1589))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1590))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1591, const char *__anonymous_object1592))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1593))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1594, _Bool __anonymous_object1595))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1596))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1597))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1598))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1599))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1600))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1601, const char *__anonymous_object1602))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1603))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1604, const char *__anonymous_object1605))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1606))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1607))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1608, const char *__anonymous_object1609, unsigned long int __anonymous_object1610))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1611, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret7=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1612))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1613))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1614, _Bool __anonymous_object1615))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1616))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1617, const char *__anonymous_object1618))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1619))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1620, _Bool __anonymous_object1621))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1622))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1623))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1624))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1625))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1626))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1627, const char *__anonymous_object1628))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1629))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1630, const char *__anonymous_object1631))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1632))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1633))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1634, const char *__anonymous_object1635, unsigned long int __anonymous_object1636))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1637, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1638))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1639))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1640, _Bool __anonymous_object1641))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1642))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1643, const char *__anonymous_object1644))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1645))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1646, _Bool __anonymous_object1647))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1648))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1649))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1651))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1652))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1653, const char *__anonymous_object1654))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1655))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1656, const char *__anonymous_object1657))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1658))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1659))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1660, const char *__anonymous_object1661, unsigned long int __anonymous_object1662))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1663, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret6)), __v__Uc_1)))) , _tmp_cp_ret7)), ((void *(*)(void *__anonymous_object1664))(&_thunk2)))))) , _tmp_cp_ret8)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1589))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1590))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1591, _Bool __anonymous_object1592))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1593))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1594, const char *__anonymous_object1595))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1596))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1597, _Bool __anonymous_object1598))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1599))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1600))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1601))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1602))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1603))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1604, const char *__anonymous_object1605))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1606))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1607, const char *__anonymous_object1608))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1609))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1610))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1611, const char *__anonymous_object1612, unsigned long int __anonymous_object1613))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1614, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret8=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1615))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1616))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1617, _Bool __anonymous_object1618))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1619))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1620, const char *__anonymous_object1621))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1622))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1623, _Bool __anonymous_object1624))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1625))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1626))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1627))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1628))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1629))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1630, const char *__anonymous_object1631))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1632))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1633, const char *__anonymous_object1634))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1635))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1636))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1637, const char *__anonymous_object1638, unsigned long int __anonymous_object1639))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1640, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret7=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1641))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1642))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1643, _Bool __anonymous_object1644))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1645))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1646, const char *__anonymous_object1647))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1648))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1649, _Bool __anonymous_object1650))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1651))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1652))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1653))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1654))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1655))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1656, const char *__anonymous_object1657))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1658))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1659, const char *__anonymous_object1660))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1661))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1662))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1663, const char *__anonymous_object1664, unsigned long int __anonymous_object1665))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1666, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1667))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1668))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1669, _Bool __anonymous_object1670))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1671))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1672, const char *__anonymous_object1673))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1674))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1675, _Bool __anonymous_object1676))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1677))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1678))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1679))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1680))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1681))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1682, const char *__anonymous_object1683))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1684))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1685, const char *__anonymous_object1686))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1687))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1688))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1689, const char *__anonymous_object1690, unsigned long int __anonymous_object1691))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1692, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret6)), __v__Uc_1)))) , _tmp_cp_ret7)), ((void *(*)(void *__anonymous_object1693))(&_thunk2)))))) , _tmp_cp_ret8)); } void __f__F_s__1(signed short int __v__s_1){ @@ -495,7 +498,7 @@ struct ofstream *_tmp_cp_ret11; __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1665))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1666))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1667, _Bool __anonymous_object1668))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1669))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1670, const char *__anonymous_object1671))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1672))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1673, _Bool __anonymous_object1674))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1675))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1676))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1677))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1678))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1679))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1680, const char *__anonymous_object1681))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1682))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1683, const char *__anonymous_object1684))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1685))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1686))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1687, const char *__anonymous_object1688, unsigned long int __anonymous_object1689))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1690, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret11=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1691))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1692))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1693, _Bool __anonymous_object1694))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1695))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1696, const char *__anonymous_object1697))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1698))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1699, _Bool __anonymous_object1700))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1701))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1702))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1703))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1704))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1705))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1706, const char *__anonymous_object1707))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1708))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1709, const char *__anonymous_object1710))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1711))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1712))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1713, const char *__anonymous_object1714, unsigned long int __anonymous_object1715))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1716, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret10=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(((_Bool (*)(void *__anonymous_object1717))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1718))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1719, _Bool __anonymous_object1720))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1721))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1722, const char *__anonymous_object1723))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1724))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1725, _Bool __anonymous_object1726))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1727))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1728))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1729))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1730))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1731))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1732, const char *__anonymous_object1733))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1734))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1735, const char *__anonymous_object1736))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1737))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1738))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1739, const char *__anonymous_object1740, unsigned long int __anonymous_object1741))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1742, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1743))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1744))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1745, _Bool __anonymous_object1746))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1747))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1748, const char *__anonymous_object1749))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1750))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1751, _Bool __anonymous_object1752))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1753))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1754))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1756))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1757))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1758, const char *__anonymous_object1759))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1760))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1761, const char *__anonymous_object1762))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1763))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1764))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1765, const char *__anonymous_object1766, unsigned long int __anonymous_object1767))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1768, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret9)), __v__s_1)))) , _tmp_cp_ret10)), ((void *(*)(void *__anonymous_object1769))(&_thunk3)))))) , _tmp_cp_ret11)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1694))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1695))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1696, _Bool __anonymous_object1697))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1698))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1699, const char *__anonymous_object1700))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1701))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1702, _Bool __anonymous_object1703))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1704))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1705))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1706))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1707))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1708))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1709, const char *__anonymous_object1710))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1711))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1712, const char *__anonymous_object1713))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1714))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1715))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1716, const char *__anonymous_object1717, unsigned long int __anonymous_object1718))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1719, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret11=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1720))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1721))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1722, _Bool __anonymous_object1723))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1724))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1725, const char *__anonymous_object1726))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1727))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1728, _Bool __anonymous_object1729))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1730))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1731))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1732))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1733))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1734))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1735, const char *__anonymous_object1736))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1737))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1738, const char *__anonymous_object1739))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1740))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1741))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1742, const char *__anonymous_object1743, unsigned long int __anonymous_object1744))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1745, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret10=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(((_Bool (*)(void *__anonymous_object1746))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1747))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1748, _Bool __anonymous_object1749))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1750))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1751, const char *__anonymous_object1752))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1753))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1754, _Bool __anonymous_object1755))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1756))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1757))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1758))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1759))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1760))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1761, const char *__anonymous_object1762))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1763))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1764, const char *__anonymous_object1765))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1766))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1767))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1768, const char *__anonymous_object1769, unsigned long int __anonymous_object1770))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1771, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1772))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1773))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1774, _Bool __anonymous_object1775))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1776))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1777, const char *__anonymous_object1778))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1779))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1780, _Bool __anonymous_object1781))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1782))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1783))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1784))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1785))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1786))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1787, const char *__anonymous_object1788))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1789))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1790, const char *__anonymous_object1791))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1792))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1793))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1794, const char *__anonymous_object1795, unsigned long int __anonymous_object1796))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1797, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret9)), __v__s_1)))) , _tmp_cp_ret10)), ((void *(*)(void *__anonymous_object1798))(&_thunk3)))))) , _tmp_cp_ret11)); } void __f__F_Us__1(unsigned short int __v__Us_1){ @@ -504,7 +507,7 @@ struct ofstream *_tmp_cp_ret14; __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1770))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1771))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1772, _Bool __anonymous_object1773))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1774))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1775, const char *__anonymous_object1776))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1777))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1778, _Bool __anonymous_object1779))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1780))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1781))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1782))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1783))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1784))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1785, const char *__anonymous_object1786))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1787))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1788, const char *__anonymous_object1789))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1790))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1791))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1792, const char *__anonymous_object1793, unsigned long int __anonymous_object1794))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1795, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret14=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1796))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1797))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1798, _Bool __anonymous_object1799))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1800))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1801, const char *__anonymous_object1802))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1803))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1804, _Bool __anonymous_object1805))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1806))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1807))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1808))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1809))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1810))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1811, const char *__anonymous_object1812))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1813))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1814, const char *__anonymous_object1815))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1816))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1817))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1818, const char *__anonymous_object1819, unsigned long int __anonymous_object1820))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1821, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret13=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(((_Bool (*)(void *__anonymous_object1822))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1823))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1824, _Bool __anonymous_object1825))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1826))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1827, const char *__anonymous_object1828))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1829))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1830, _Bool __anonymous_object1831))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1832))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1833))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1834))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1835))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1836))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1837, const char *__anonymous_object1838))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1839))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1840, const char *__anonymous_object1841))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1842))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1843))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1844, const char *__anonymous_object1845, unsigned long int __anonymous_object1846))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1847, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1848))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1849))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1850, _Bool __anonymous_object1851))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1852))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1853, const char *__anonymous_object1854))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1855))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1856, _Bool __anonymous_object1857))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1858))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1859))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1861))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1862))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1863, const char *__anonymous_object1864))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1865))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1866, const char *__anonymous_object1867))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1868))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1869))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1870, const char *__anonymous_object1871, unsigned long int __anonymous_object1872))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1873, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret12)), __v__Us_1)))) , _tmp_cp_ret13)), ((void *(*)(void *__anonymous_object1874))(&_thunk4)))))) , _tmp_cp_ret14)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1799))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1800))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1801, _Bool __anonymous_object1802))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1803))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1804, const char *__anonymous_object1805))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1806))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1807, _Bool __anonymous_object1808))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1809))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1810))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1811))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1812))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1813))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1814, const char *__anonymous_object1815))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1816))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1817, const char *__anonymous_object1818))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1819))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1820))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1821, const char *__anonymous_object1822, unsigned long int __anonymous_object1823))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1824, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret14=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1825))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1826))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1827, _Bool __anonymous_object1828))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1829))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1830, const char *__anonymous_object1831))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1832))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1833, _Bool __anonymous_object1834))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1835))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1836))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1837))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1838))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1839))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1840, const char *__anonymous_object1841))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1842))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1843, const char *__anonymous_object1844))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1845))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1846))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1847, const char *__anonymous_object1848, unsigned long int __anonymous_object1849))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1850, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret13=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(((_Bool (*)(void *__anonymous_object1851))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1852))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1853, _Bool __anonymous_object1854))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1855))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1856, const char *__anonymous_object1857))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1858))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1859, _Bool __anonymous_object1860))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1861))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1862))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1863))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1864))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1865))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1866, const char *__anonymous_object1867))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1868))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1869, const char *__anonymous_object1870))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1871))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1872))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1873, const char *__anonymous_object1874, unsigned long int __anonymous_object1875))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1876, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1877))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1878))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1879, _Bool __anonymous_object1880))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1881))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1882, const char *__anonymous_object1883))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1884))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1885, _Bool __anonymous_object1886))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1887))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1888))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1889))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1890))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1891))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1892, const char *__anonymous_object1893))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1894))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1895, const char *__anonymous_object1896))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1897))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1898))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1899, const char *__anonymous_object1900, unsigned long int __anonymous_object1901))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1902, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret12)), __v__Us_1)))) , _tmp_cp_ret13)), ((void *(*)(void *__anonymous_object1903))(&_thunk4)))))) , _tmp_cp_ret14)); } void __f__F_Ul__1(unsigned long int __v__Ul_1){ @@ -513,7 +516,7 @@ struct ofstream *_tmp_cp_ret17; __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1875))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1876))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1877, _Bool __anonymous_object1878))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1879))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1880, const char *__anonymous_object1881))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1882))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1883, _Bool __anonymous_object1884))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1885))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1886))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1887))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1888))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1889))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1890, const char *__anonymous_object1891))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1892))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1893, const char *__anonymous_object1894))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1895))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1896))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1897, const char *__anonymous_object1898, unsigned long int __anonymous_object1899))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1900, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret17=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1901))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1902))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1903, _Bool __anonymous_object1904))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1905))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1906, const char *__anonymous_object1907))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1908))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1909, _Bool __anonymous_object1910))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1911))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1912))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1913))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1914))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1915))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1916, const char *__anonymous_object1917))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1918))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1919, const char *__anonymous_object1920))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1921))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1922))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1923, const char *__anonymous_object1924, unsigned long int __anonymous_object1925))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1926, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret16=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ul__1(((_Bool (*)(void *__anonymous_object1927))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1928))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1929, _Bool __anonymous_object1930))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1931))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1932, const char *__anonymous_object1933))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1934))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1935, _Bool __anonymous_object1936))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1937))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1938))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1939))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1940))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1941))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1942, const char *__anonymous_object1943))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1944))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1945, const char *__anonymous_object1946))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1947))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1948))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1949, const char *__anonymous_object1950, unsigned long int __anonymous_object1951))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1952, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1953))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1954))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1955, _Bool __anonymous_object1956))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1957))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1958, const char *__anonymous_object1959))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1960))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1961, _Bool __anonymous_object1962))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1963))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1964))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1965))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1966))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1967))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1968, const char *__anonymous_object1969))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1970))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1971, const char *__anonymous_object1972))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1973))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1974))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1975, const char *__anonymous_object1976, unsigned long int __anonymous_object1977))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1978, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret15)), __v__Ul_1)))) , _tmp_cp_ret16)), ((void *(*)(void *__anonymous_object1979))(&_thunk5)))))) , _tmp_cp_ret17)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1904))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1905))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1906, _Bool __anonymous_object1907))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1908))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1909, const char *__anonymous_object1910))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1911))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1912, _Bool __anonymous_object1913))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1914))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1915))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1916))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1917))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1918))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1919, const char *__anonymous_object1920))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1921))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1922, const char *__anonymous_object1923))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1924))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1925))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1926, const char *__anonymous_object1927, unsigned long int __anonymous_object1928))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1929, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret17=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1930))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1931))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1932, _Bool __anonymous_object1933))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1934))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1935, const char *__anonymous_object1936))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1937))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1938, _Bool __anonymous_object1939))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1940))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1941))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1942))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1943))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1944))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1945, const char *__anonymous_object1946))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1947))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1948, const char *__anonymous_object1949))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1950))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1951))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1952, const char *__anonymous_object1953, unsigned long int __anonymous_object1954))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1955, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret16=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ul__1(((_Bool (*)(void *__anonymous_object1956))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1957))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1958, _Bool __anonymous_object1959))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1960))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1961, const char *__anonymous_object1962))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1963))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1964, _Bool __anonymous_object1965))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1966))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1967))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1968))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1969))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1970))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1971, const char *__anonymous_object1972))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1973))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1974, const char *__anonymous_object1975))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1976))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1977))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1978, const char *__anonymous_object1979, unsigned long int __anonymous_object1980))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1981, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1982))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1983))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1984, _Bool __anonymous_object1985))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1986))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1987, const char *__anonymous_object1988))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1989))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1990, _Bool __anonymous_object1991))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1992))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1993))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1994))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1995))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1996))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1997, const char *__anonymous_object1998))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1999))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2000, const char *__anonymous_object2001))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object2002))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object2003))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object2004, const char *__anonymous_object2005, unsigned long int __anonymous_object2006))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object2007, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret15)), __v__Ul_1)))) , _tmp_cp_ret16)), ((void *(*)(void *__anonymous_object2008))(&_thunk5)))))) , _tmp_cp_ret17)); } signed int __main__Fi___1(){ Index: src/tests/.expect/literals.x86.txt =================================================================== --- src/tests/.expect/literals.x86.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/.expect/literals.x86.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -35,21 +35,24 @@ void __write__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object992)(), void *__anonymous_object993), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object994)(), void *__anonymous_object995, void *__anonymous_object996), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object997)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object998), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object999)(), void *__anonymous_object1000, void *__anonymous_object1001), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1002)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1003, void *__anonymous_object1004), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1005)(), void *__anonymous_object1006, void *__anonymous_object1007), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1008)(), void *__anonymous_object1009, void *__anonymous_object1010), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1011)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1012, void *__anonymous_object1013), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1014, void *__anonymous_object1015), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1016), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1017, void *__anonymous_object1018), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1019), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1020, void *__anonymous_object1021), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1022), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1023), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1024, _Bool __anonymous_object1025), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1026), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1027, const char *__anonymous_object1028), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1029), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1030, _Bool __anonymous_object1031), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1032), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1033), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1034), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1035), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1036), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1037, const char *__anonymous_object1038), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1039), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1040, const char *__anonymous_object1041), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1042), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1043), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1044, const char *__anonymous_object1045, unsigned long int __anonymous_object1046), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1047, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1048, void *__anonymous_object1049), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1050), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1051, void *__anonymous_object1052), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1053), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1054), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1055), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1056, void *__anonymous_object1057), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1058, void *__anonymous_object1059), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1060), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1); void __write_reverse__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object1061)(), void *__anonymous_object1062), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object1063)(), void *__anonymous_object1064, void *__anonymous_object1065), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object1066)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object1067), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object1068)(), void *__anonymous_object1069, void *__anonymous_object1070), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1071)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1072, void *__anonymous_object1073), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1074)(), void *__anonymous_object1075, void *__anonymous_object1076), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1077)(), void *__anonymous_object1078, void *__anonymous_object1079), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1080)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1081, void *__anonymous_object1082), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1083, void *__anonymous_object1084), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1085), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1086, void *__anonymous_object1087), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1088), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1089, void *__anonymous_object1090), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1091), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1092), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1093, _Bool __anonymous_object1094), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1095), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1096, const char *__anonymous_object1097), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1098), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1099, _Bool __anonymous_object1100), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1101), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1102), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1103), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1104), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1105), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1106, const char *__anonymous_object1107), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1108), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1109, const char *__anonymous_object1110), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1111), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1112), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1113, const char *__anonymous_object1114, unsigned long int __anonymous_object1115), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1116, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1117, void *__anonymous_object1118), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1119), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1120, void *__anonymous_object1121), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1122), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1123), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1124), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1125, void *__anonymous_object1126), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1127, void *__anonymous_object1128), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1129), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1130), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1131), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1132, char *__anonymous_object1133, unsigned long int __anonymous_object1134), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1135, char __anonymous_object1136), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1137, const char *__fmt__PCc_1, ...), void *__anonymous_object1138, char *__anonymous_object1139); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1140), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1141), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1142, char *__anonymous_object1143, unsigned long int __anonymous_object1144), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1145, char __anonymous_object1146), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1147, const char *__fmt__PCc_1, ...), void *__anonymous_object1148, signed char *__anonymous_object1149); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1150), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1151), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1152, char *__anonymous_object1153, unsigned long int __anonymous_object1154), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1155, char __anonymous_object1156), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1157, const char *__fmt__PCc_1, ...), void *__anonymous_object1158, unsigned char *__anonymous_object1159); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1160), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1161), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1162, char *__anonymous_object1163, unsigned long int __anonymous_object1164), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1165, char __anonymous_object1166), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1167, const char *__fmt__PCc_1, ...), void *__anonymous_object1168, signed short int *__anonymous_object1169); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1170), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1171), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1172, char *__anonymous_object1173, unsigned long int __anonymous_object1174), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1175, char __anonymous_object1176), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1177, const char *__fmt__PCc_1, ...), void *__anonymous_object1178, unsigned short int *__anonymous_object1179); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Ri__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1180), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1181), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1182, char *__anonymous_object1183, unsigned long int __anonymous_object1184), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1185, char __anonymous_object1186), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1187, const char *__fmt__PCc_1, ...), void *__anonymous_object1188, signed int *__anonymous_object1189); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUi__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1190), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1191), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1192, char *__anonymous_object1193, unsigned long int __anonymous_object1194), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1195, char __anonymous_object1196), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1197, const char *__fmt__PCc_1, ...), void *__anonymous_object1198, unsigned int *__anonymous_object1199); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1200), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1201), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1202, char *__anonymous_object1203, unsigned long int __anonymous_object1204), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1205, char __anonymous_object1206), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1207, const char *__fmt__PCc_1, ...), void *__anonymous_object1208, signed long int *__anonymous_object1209); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1210), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1211), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1212, char *__anonymous_object1213, unsigned long int __anonymous_object1214), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1215, char __anonymous_object1216), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1217, const char *__fmt__PCc_1, ...), void *__anonymous_object1218, signed long long int *__anonymous_object1219); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1220), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1221), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1222, char *__anonymous_object1223, unsigned long int __anonymous_object1224), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1225, char __anonymous_object1226), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1227, const char *__fmt__PCc_1, ...), void *__anonymous_object1228, unsigned long int *__anonymous_object1229); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1230), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1231), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1232, char *__anonymous_object1233, unsigned long int __anonymous_object1234), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1235, char __anonymous_object1236), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1237, const char *__fmt__PCc_1, ...), void *__anonymous_object1238, unsigned long long int *__anonymous_object1239); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1240), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1241), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1242, char *__anonymous_object1243, unsigned long int __anonymous_object1244), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1245, char __anonymous_object1246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1247, const char *__fmt__PCc_1, ...), void *__anonymous_object1248, float *__anonymous_object1249); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1250), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1251), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1252, char *__anonymous_object1253, unsigned long int __anonymous_object1254), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1255, char __anonymous_object1256), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1257, const char *__fmt__PCc_1, ...), void *__anonymous_object1258, double *__anonymous_object1259); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1260), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1261), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1262, char *__anonymous_object1263, unsigned long int __anonymous_object1264), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1265, char __anonymous_object1266), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1267, const char *__fmt__PCc_1, ...), void *__anonymous_object1268, long double *__anonymous_object1269); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1270), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1271), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1272, char *__anonymous_object1273, unsigned long int __anonymous_object1274), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1275, char __anonymous_object1276), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1277, const char *__fmt__PCc_1, ...), void *__anonymous_object1278, float _Complex *__anonymous_object1279); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1280), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1281), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1282, char *__anonymous_object1283, unsigned long int __anonymous_object1284), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1285, char __anonymous_object1286), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1287, const char *__fmt__PCc_1, ...), void *__anonymous_object1288, double _Complex *__anonymous_object1289); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1290), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1291), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1292, char *__anonymous_object1293, unsigned long int __anonymous_object1294), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1295, char __anonymous_object1296), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1297, const char *__fmt__PCc_1, ...), void *__anonymous_object1298, long double _Complex *__anonymous_object1299); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rb__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1130), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1131), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1132, char *__anonymous_object1133, unsigned long int __anonymous_object1134), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1135, char __anonymous_object1136), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1137, const char *__fmt__PCc_1, ...), void *__anonymous_object1138, _Bool *__anonymous_object1139); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1140), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1141), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1142, char *__anonymous_object1143, unsigned long int __anonymous_object1144), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1145, char __anonymous_object1146), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1147, const char *__fmt__PCc_1, ...), void *__anonymous_object1148, char *__anonymous_object1149); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1150), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1151), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1152, char *__anonymous_object1153, unsigned long int __anonymous_object1154), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1155, char __anonymous_object1156), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1157, const char *__fmt__PCc_1, ...), void *__anonymous_object1158, signed char *__anonymous_object1159); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1160), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1161), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1162, char *__anonymous_object1163, unsigned long int __anonymous_object1164), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1165, char __anonymous_object1166), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1167, const char *__fmt__PCc_1, ...), void *__anonymous_object1168, unsigned char *__anonymous_object1169); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1170), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1171), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1172, char *__anonymous_object1173, unsigned long int __anonymous_object1174), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1175, char __anonymous_object1176), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1177, const char *__fmt__PCc_1, ...), void *__anonymous_object1178, signed short int *__anonymous_object1179); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1180), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1181), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1182, char *__anonymous_object1183, unsigned long int __anonymous_object1184), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1185, char __anonymous_object1186), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1187, const char *__fmt__PCc_1, ...), void *__anonymous_object1188, unsigned short int *__anonymous_object1189); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Ri__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1190), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1191), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1192, char *__anonymous_object1193, unsigned long int __anonymous_object1194), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1195, char __anonymous_object1196), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1197, const char *__fmt__PCc_1, ...), void *__anonymous_object1198, signed int *__anonymous_object1199); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUi__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1200), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1201), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1202, char *__anonymous_object1203, unsigned long int __anonymous_object1204), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1205, char __anonymous_object1206), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1207, const char *__fmt__PCc_1, ...), void *__anonymous_object1208, unsigned int *__anonymous_object1209); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1210), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1211), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1212, char *__anonymous_object1213, unsigned long int __anonymous_object1214), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1215, char __anonymous_object1216), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1217, const char *__fmt__PCc_1, ...), void *__anonymous_object1218, signed long int *__anonymous_object1219); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1220), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1221), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1222, char *__anonymous_object1223, unsigned long int __anonymous_object1224), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1225, char __anonymous_object1226), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1227, const char *__fmt__PCc_1, ...), void *__anonymous_object1228, signed long long int *__anonymous_object1229); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1230), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1231), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1232, char *__anonymous_object1233, unsigned long int __anonymous_object1234), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1235, char __anonymous_object1236), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1237, const char *__fmt__PCc_1, ...), void *__anonymous_object1238, unsigned long int *__anonymous_object1239); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1240), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1241), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1242, char *__anonymous_object1243, unsigned long int __anonymous_object1244), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1245, char __anonymous_object1246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1247, const char *__fmt__PCc_1, ...), void *__anonymous_object1248, unsigned long long int *__anonymous_object1249); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1250), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1251), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1252, char *__anonymous_object1253, unsigned long int __anonymous_object1254), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1255, char __anonymous_object1256), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1257, const char *__fmt__PCc_1, ...), void *__anonymous_object1258, float *__anonymous_object1259); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1260), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1261), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1262, char *__anonymous_object1263, unsigned long int __anonymous_object1264), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1265, char __anonymous_object1266), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1267, const char *__fmt__PCc_1, ...), void *__anonymous_object1268, double *__anonymous_object1269); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1270), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1271), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1272, char *__anonymous_object1273, unsigned long int __anonymous_object1274), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1275, char __anonymous_object1276), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1277, const char *__fmt__PCc_1, ...), void *__anonymous_object1278, long double *__anonymous_object1279); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1280), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1281), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1282, char *__anonymous_object1283, unsigned long int __anonymous_object1284), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1285, char __anonymous_object1286), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1287, const char *__fmt__PCc_1, ...), void *__anonymous_object1288, float _Complex *__anonymous_object1289); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1290), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1291), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1292, char *__anonymous_object1293, unsigned long int __anonymous_object1294), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1295, char __anonymous_object1296), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1297, const char *__fmt__PCc_1, ...), void *__anonymous_object1298, double _Complex *__anonymous_object1299); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1300), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1301), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1302, char *__anonymous_object1303, unsigned long int __anonymous_object1304), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1305, char __anonymous_object1306), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1307, const char *__fmt__PCc_1, ...), void *__anonymous_object1308, long double _Complex *__anonymous_object1309); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1310), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1311), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1312, char *__anonymous_object1313, unsigned long int __anonymous_object1314), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1315, char __anonymous_object1316), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1317, const char *__fmt__PCc_1, ...), void *__anonymous_object1318, void *(*__anonymous_object1319)(void *__anonymous_object1320)); +void *__endl__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1321), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1322), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1323, char *__anonymous_object1324, unsigned long int __anonymous_object1325), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1326, char __anonymous_object1327), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1328, const char *__fmt__PCc_1, ...), void *__is__R7tistype_1); struct _Istream_cstrUC { char *__s__Pc_1; @@ -78,6 +81,6 @@ ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=__s__Pc_1) /* ?{} */); } -struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1300); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1301), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1302), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1303, char *__anonymous_object1304, unsigned long int __anonymous_object1305), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1306, char __anonymous_object1307), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1308, const char *__fmt__PCc_1, ...), void *__anonymous_object1309, struct _Istream_cstrUC __anonymous_object1310); +struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1329); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1330), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1331), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1332, char *__anonymous_object1333, unsigned long int __anonymous_object1334), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1335, char __anonymous_object1336), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1337, const char *__fmt__PCc_1, ...), void *__anonymous_object1338, struct _Istream_cstrUC __anonymous_object1339); struct _Istream_cstrC { char *__s__Pc_1; @@ -117,6 +120,6 @@ ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=__size__i_1) /* ?{} */); } -struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1311, signed int __size__i_1); -void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1312), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1313), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1314, char *__anonymous_object1315, unsigned long int __anonymous_object1316), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1317, char __anonymous_object1318), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1319, const char *__fmt__PCc_1, ...), void *__anonymous_object1320, struct _Istream_cstrC __anonymous_object1321); +struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1340, signed int __size__i_1); +void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1341), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1342), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1343, char *__anonymous_object1344, unsigned long int __anonymous_object1345), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1346, char __anonymous_object1347), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1348, const char *__fmt__PCc_1, ...), void *__anonymous_object1349, struct _Istream_cstrC __anonymous_object1350); enum __anonymous0 { __sepSize__C13e__anonymous0_1 = 16, @@ -398,26 +401,26 @@ } -_Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1322); -void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1323); -void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1324, _Bool __anonymous_object1325); -const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1326); -void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1327, const char *__anonymous_object1328); -_Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1329); -void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1330, _Bool __anonymous_object1331); -void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1332); -void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1333); -_Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1334); -_Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1335); -const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1336); -void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1337, const char *__anonymous_object1338); -const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1339); -void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1340, const char *__anonymous_object1341); -signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1342); -signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1343); -void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1344, const char *__name__PCc_1, const char *__mode__PCc_1); -void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1345, const char *__name__PCc_1); -void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1346); -struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1347, const char *__data__PCc_1, unsigned long int __size__Ul_1); -signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1348, const char *__fmt__PCc_1, ...); +_Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1351); +void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1352); +void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1353, _Bool __anonymous_object1354); +const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1355); +void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1356, const char *__anonymous_object1357); +_Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1358); +void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1359, _Bool __anonymous_object1360); +void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1361); +void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1362); +_Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1363); +_Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1364); +const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1365); +void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1366, const char *__anonymous_object1367); +const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1368); +void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1369, const char *__anonymous_object1370); +signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1371); +signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1372); +void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1373, const char *__name__PCc_1, const char *__mode__PCc_1); +void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1374, const char *__name__PCc_1); +void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1375); +struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1376, const char *__data__PCc_1, unsigned long int __size__Ul_1); +signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1377, const char *__fmt__PCc_1, ...); void ___constructor__F_R9sofstream__1(struct ofstream *__os__R9sofstream_1); void ___constructor__F_R9sofstreamPCcPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1); @@ -458,5 +461,5 @@ struct ifstream *__read__FR9sifstream_R9sifstreamPcUl__1(struct ifstream *__is__R9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1); struct ifstream *__ungetc__FR9sifstream_R9sifstreamc__1(struct ifstream *__is__R9sifstream_1, char __c__c_1); -signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1349, const char *__fmt__PCc_1, ...); +signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1378, const char *__fmt__PCc_1, ...); void ___constructor__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1); void ___constructor__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1); @@ -468,7 +471,7 @@ struct ofstream *_tmp_cp_ret2; __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1350))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1351))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1352, _Bool __anonymous_object1353))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1354))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1355, const char *__anonymous_object1356))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1357))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1358, _Bool __anonymous_object1359))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1360))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1361))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1362))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1363))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1364))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1365, const char *__anonymous_object1366))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1367))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1368, const char *__anonymous_object1369))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1370))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1371))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1372, const char *__anonymous_object1373, unsigned long int __anonymous_object1374))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1375, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret2=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1376))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1377))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1378, _Bool __anonymous_object1379))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1380))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1381, const char *__anonymous_object1382))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1383))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1384, _Bool __anonymous_object1385))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1386))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1387))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1388))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1389))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1390))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1391, const char *__anonymous_object1392))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1393))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1394, const char *__anonymous_object1395))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1396))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1397))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1398, const char *__anonymous_object1399, unsigned long int __anonymous_object1400))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1401, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret1=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(((_Bool (*)(void *__anonymous_object1402))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1403))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1404, _Bool __anonymous_object1405))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1406))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1407, const char *__anonymous_object1408))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1409))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1410, _Bool __anonymous_object1411))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1412))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1413))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1414))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1415))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1416))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1417, const char *__anonymous_object1418))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1419))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1420, const char *__anonymous_object1421))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1422))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1423))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1424, const char *__anonymous_object1425, unsigned long int __anonymous_object1426))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1427, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret0=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1428))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1429))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1430, _Bool __anonymous_object1431))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1432))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1433, const char *__anonymous_object1434))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1435))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1436, _Bool __anonymous_object1437))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1438))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1439))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1441))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1442))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1443, const char *__anonymous_object1444))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1445))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1446, const char *__anonymous_object1447))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1448))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1449))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1450, const char *__anonymous_object1451, unsigned long int __anonymous_object1452))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1453, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret0)), __v__c_1)))) , _tmp_cp_ret1)), ((void *(*)(void *__anonymous_object1454))(&_thunk0)))))) , _tmp_cp_ret2)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1379))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1380))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1381, _Bool __anonymous_object1382))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1383))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1384, const char *__anonymous_object1385))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1386))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1387, _Bool __anonymous_object1388))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1389))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1390))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1391))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1392))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1393))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1394, const char *__anonymous_object1395))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1396))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1397, const char *__anonymous_object1398))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1399))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1400))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1401, const char *__anonymous_object1402, unsigned long int __anonymous_object1403))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1404, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret2=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1405))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1406))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1407, _Bool __anonymous_object1408))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1409))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1410, const char *__anonymous_object1411))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1412))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1413, _Bool __anonymous_object1414))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1415))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1416))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1417))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1418))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1419))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1420, const char *__anonymous_object1421))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1422))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1423, const char *__anonymous_object1424))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1425))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1426))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1427, const char *__anonymous_object1428, unsigned long int __anonymous_object1429))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1430, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret1=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(((_Bool (*)(void *__anonymous_object1431))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1432))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1433, _Bool __anonymous_object1434))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1435))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1436, const char *__anonymous_object1437))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1438))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1439, _Bool __anonymous_object1440))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1441))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1442))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1443))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1444))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1445))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1446, const char *__anonymous_object1447))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1448))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1449, const char *__anonymous_object1450))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1451))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1452))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1453, const char *__anonymous_object1454, unsigned long int __anonymous_object1455))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1456, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret0=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1457))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1458))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1459, _Bool __anonymous_object1460))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1461))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1462, const char *__anonymous_object1463))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1464))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1465, _Bool __anonymous_object1466))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1467))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1468))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1469))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1470))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1471))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1472, const char *__anonymous_object1473))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1474))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1475, const char *__anonymous_object1476))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1477))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1478))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1479, const char *__anonymous_object1480, unsigned long int __anonymous_object1481))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1482, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret0)), __v__c_1)))) , _tmp_cp_ret1)), ((void *(*)(void *__anonymous_object1483))(&_thunk0)))))) , _tmp_cp_ret2)); } void __f__F_Sc__1(signed char __v__Sc_1){ @@ -477,7 +480,7 @@ struct ofstream *_tmp_cp_ret5; __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1455))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1456))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1457, _Bool __anonymous_object1458))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1459))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1460, const char *__anonymous_object1461))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1462))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1463, _Bool __anonymous_object1464))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1465))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1466))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1467))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1468))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1469))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1470, const char *__anonymous_object1471))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1472))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1473, const char *__anonymous_object1474))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1475))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1476))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1477, const char *__anonymous_object1478, unsigned long int __anonymous_object1479))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1480, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret5=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1481))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1482))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1483, _Bool __anonymous_object1484))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1485))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1486, const char *__anonymous_object1487))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1488))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1489, _Bool __anonymous_object1490))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1491))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1492))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1493))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1494))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1495))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1496, const char *__anonymous_object1497))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1498))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1499, const char *__anonymous_object1500))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1501))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1502))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1503, const char *__anonymous_object1504, unsigned long int __anonymous_object1505))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1506, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret4=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1507))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1508))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1509, _Bool __anonymous_object1510))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1511))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1512, const char *__anonymous_object1513))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1514))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1515, _Bool __anonymous_object1516))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1517))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1518))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1519))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1520))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1521))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1522, const char *__anonymous_object1523))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1524))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1525, const char *__anonymous_object1526))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1527))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1528))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1529, const char *__anonymous_object1530, unsigned long int __anonymous_object1531))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1532, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1533))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1534))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1535, _Bool __anonymous_object1536))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1537))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1538, const char *__anonymous_object1539))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1540))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1541, _Bool __anonymous_object1542))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1543))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1544))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1546))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1547))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1548, const char *__anonymous_object1549))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1550))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1551, const char *__anonymous_object1552))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1553))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1554))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1555, const char *__anonymous_object1556, unsigned long int __anonymous_object1557))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1558, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret3)), __v__Sc_1)))) , _tmp_cp_ret4)), ((void *(*)(void *__anonymous_object1559))(&_thunk1)))))) , _tmp_cp_ret5)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1484))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1485))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1486, _Bool __anonymous_object1487))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1488))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1489, const char *__anonymous_object1490))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1491))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1492, _Bool __anonymous_object1493))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1494))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1495))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1496))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1497))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1498))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1499, const char *__anonymous_object1500))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1501))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1502, const char *__anonymous_object1503))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1504))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1505))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1506, const char *__anonymous_object1507, unsigned long int __anonymous_object1508))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1509, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret5=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1510))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1511))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1512, _Bool __anonymous_object1513))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1514))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1515, const char *__anonymous_object1516))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1517))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1518, _Bool __anonymous_object1519))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1520))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1521))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1522))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1523))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1524))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1525, const char *__anonymous_object1526))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1527))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1528, const char *__anonymous_object1529))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1530))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1531))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1532, const char *__anonymous_object1533, unsigned long int __anonymous_object1534))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1535, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret4=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1536))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1537))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1538, _Bool __anonymous_object1539))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1540))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1541, const char *__anonymous_object1542))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1543))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1544, _Bool __anonymous_object1545))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1546))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1547))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1548))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1549))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1550))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1551, const char *__anonymous_object1552))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1553))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1554, const char *__anonymous_object1555))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1556))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1557))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1558, const char *__anonymous_object1559, unsigned long int __anonymous_object1560))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1561, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1562))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1563))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1564, _Bool __anonymous_object1565))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1566))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1567, const char *__anonymous_object1568))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1569))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1570, _Bool __anonymous_object1571))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1572))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1573))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1574))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1575))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1576))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1577, const char *__anonymous_object1578))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1579))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1580, const char *__anonymous_object1581))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1582))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1583))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1584, const char *__anonymous_object1585, unsigned long int __anonymous_object1586))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1587, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret3)), __v__Sc_1)))) , _tmp_cp_ret4)), ((void *(*)(void *__anonymous_object1588))(&_thunk1)))))) , _tmp_cp_ret5)); } void __f__F_Uc__1(unsigned char __v__Uc_1){ @@ -486,7 +489,7 @@ struct ofstream *_tmp_cp_ret8; __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1560))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1561))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1562, _Bool __anonymous_object1563))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1564))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1565, const char *__anonymous_object1566))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1567))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1568, _Bool __anonymous_object1569))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1570))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1571))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1572))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1573))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1574))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1575, const char *__anonymous_object1576))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1577))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1578, const char *__anonymous_object1579))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1580))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1581))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1582, const char *__anonymous_object1583, unsigned long int __anonymous_object1584))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1585, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret8=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1586))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1587))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1588, _Bool __anonymous_object1589))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1590))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1591, const char *__anonymous_object1592))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1593))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1594, _Bool __anonymous_object1595))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1596))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1597))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1598))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1599))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1600))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1601, const char *__anonymous_object1602))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1603))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1604, const char *__anonymous_object1605))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1606))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1607))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1608, const char *__anonymous_object1609, unsigned long int __anonymous_object1610))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1611, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret7=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1612))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1613))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1614, _Bool __anonymous_object1615))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1616))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1617, const char *__anonymous_object1618))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1619))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1620, _Bool __anonymous_object1621))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1622))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1623))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1624))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1625))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1626))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1627, const char *__anonymous_object1628))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1629))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1630, const char *__anonymous_object1631))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1632))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1633))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1634, const char *__anonymous_object1635, unsigned long int __anonymous_object1636))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1637, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1638))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1639))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1640, _Bool __anonymous_object1641))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1642))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1643, const char *__anonymous_object1644))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1645))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1646, _Bool __anonymous_object1647))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1648))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1649))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1651))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1652))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1653, const char *__anonymous_object1654))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1655))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1656, const char *__anonymous_object1657))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1658))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1659))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1660, const char *__anonymous_object1661, unsigned long int __anonymous_object1662))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1663, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret6)), __v__Uc_1)))) , _tmp_cp_ret7)), ((void *(*)(void *__anonymous_object1664))(&_thunk2)))))) , _tmp_cp_ret8)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1589))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1590))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1591, _Bool __anonymous_object1592))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1593))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1594, const char *__anonymous_object1595))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1596))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1597, _Bool __anonymous_object1598))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1599))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1600))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1601))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1602))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1603))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1604, const char *__anonymous_object1605))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1606))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1607, const char *__anonymous_object1608))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1609))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1610))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1611, const char *__anonymous_object1612, unsigned long int __anonymous_object1613))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1614, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret8=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1615))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1616))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1617, _Bool __anonymous_object1618))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1619))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1620, const char *__anonymous_object1621))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1622))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1623, _Bool __anonymous_object1624))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1625))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1626))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1627))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1628))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1629))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1630, const char *__anonymous_object1631))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1632))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1633, const char *__anonymous_object1634))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1635))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1636))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1637, const char *__anonymous_object1638, unsigned long int __anonymous_object1639))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1640, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret7=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1641))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1642))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1643, _Bool __anonymous_object1644))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1645))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1646, const char *__anonymous_object1647))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1648))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1649, _Bool __anonymous_object1650))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1651))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1652))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1653))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1654))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1655))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1656, const char *__anonymous_object1657))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1658))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1659, const char *__anonymous_object1660))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1661))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1662))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1663, const char *__anonymous_object1664, unsigned long int __anonymous_object1665))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1666, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1667))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1668))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1669, _Bool __anonymous_object1670))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1671))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1672, const char *__anonymous_object1673))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1674))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1675, _Bool __anonymous_object1676))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1677))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1678))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1679))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1680))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1681))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1682, const char *__anonymous_object1683))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1684))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1685, const char *__anonymous_object1686))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1687))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1688))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1689, const char *__anonymous_object1690, unsigned long int __anonymous_object1691))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1692, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret6)), __v__Uc_1)))) , _tmp_cp_ret7)), ((void *(*)(void *__anonymous_object1693))(&_thunk2)))))) , _tmp_cp_ret8)); } void __f__F_s__1(signed short int __v__s_1){ @@ -495,7 +498,7 @@ struct ofstream *_tmp_cp_ret11; __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1665))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1666))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1667, _Bool __anonymous_object1668))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1669))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1670, const char *__anonymous_object1671))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1672))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1673, _Bool __anonymous_object1674))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1675))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1676))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1677))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1678))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1679))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1680, const char *__anonymous_object1681))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1682))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1683, const char *__anonymous_object1684))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1685))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1686))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1687, const char *__anonymous_object1688, unsigned long int __anonymous_object1689))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1690, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret11=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1691))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1692))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1693, _Bool __anonymous_object1694))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1695))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1696, const char *__anonymous_object1697))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1698))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1699, _Bool __anonymous_object1700))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1701))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1702))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1703))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1704))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1705))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1706, const char *__anonymous_object1707))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1708))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1709, const char *__anonymous_object1710))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1711))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1712))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1713, const char *__anonymous_object1714, unsigned long int __anonymous_object1715))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1716, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret10=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(((_Bool (*)(void *__anonymous_object1717))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1718))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1719, _Bool __anonymous_object1720))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1721))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1722, const char *__anonymous_object1723))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1724))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1725, _Bool __anonymous_object1726))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1727))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1728))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1729))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1730))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1731))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1732, const char *__anonymous_object1733))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1734))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1735, const char *__anonymous_object1736))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1737))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1738))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1739, const char *__anonymous_object1740, unsigned long int __anonymous_object1741))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1742, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1743))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1744))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1745, _Bool __anonymous_object1746))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1747))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1748, const char *__anonymous_object1749))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1750))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1751, _Bool __anonymous_object1752))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1753))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1754))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1756))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1757))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1758, const char *__anonymous_object1759))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1760))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1761, const char *__anonymous_object1762))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1763))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1764))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1765, const char *__anonymous_object1766, unsigned long int __anonymous_object1767))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1768, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret9)), __v__s_1)))) , _tmp_cp_ret10)), ((void *(*)(void *__anonymous_object1769))(&_thunk3)))))) , _tmp_cp_ret11)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1694))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1695))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1696, _Bool __anonymous_object1697))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1698))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1699, const char *__anonymous_object1700))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1701))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1702, _Bool __anonymous_object1703))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1704))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1705))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1706))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1707))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1708))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1709, const char *__anonymous_object1710))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1711))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1712, const char *__anonymous_object1713))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1714))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1715))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1716, const char *__anonymous_object1717, unsigned long int __anonymous_object1718))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1719, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret11=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1720))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1721))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1722, _Bool __anonymous_object1723))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1724))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1725, const char *__anonymous_object1726))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1727))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1728, _Bool __anonymous_object1729))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1730))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1731))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1732))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1733))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1734))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1735, const char *__anonymous_object1736))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1737))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1738, const char *__anonymous_object1739))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1740))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1741))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1742, const char *__anonymous_object1743, unsigned long int __anonymous_object1744))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1745, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret10=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(((_Bool (*)(void *__anonymous_object1746))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1747))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1748, _Bool __anonymous_object1749))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1750))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1751, const char *__anonymous_object1752))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1753))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1754, _Bool __anonymous_object1755))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1756))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1757))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1758))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1759))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1760))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1761, const char *__anonymous_object1762))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1763))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1764, const char *__anonymous_object1765))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1766))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1767))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1768, const char *__anonymous_object1769, unsigned long int __anonymous_object1770))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1771, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1772))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1773))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1774, _Bool __anonymous_object1775))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1776))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1777, const char *__anonymous_object1778))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1779))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1780, _Bool __anonymous_object1781))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1782))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1783))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1784))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1785))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1786))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1787, const char *__anonymous_object1788))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1789))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1790, const char *__anonymous_object1791))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1792))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1793))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1794, const char *__anonymous_object1795, unsigned long int __anonymous_object1796))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1797, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret9)), __v__s_1)))) , _tmp_cp_ret10)), ((void *(*)(void *__anonymous_object1798))(&_thunk3)))))) , _tmp_cp_ret11)); } void __f__F_Us__1(unsigned short int __v__Us_1){ @@ -504,7 +507,7 @@ struct ofstream *_tmp_cp_ret14; __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1770))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1771))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1772, _Bool __anonymous_object1773))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1774))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1775, const char *__anonymous_object1776))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1777))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1778, _Bool __anonymous_object1779))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1780))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1781))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1782))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1783))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1784))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1785, const char *__anonymous_object1786))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1787))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1788, const char *__anonymous_object1789))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1790))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1791))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1792, const char *__anonymous_object1793, unsigned long int __anonymous_object1794))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1795, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret14=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1796))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1797))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1798, _Bool __anonymous_object1799))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1800))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1801, const char *__anonymous_object1802))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1803))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1804, _Bool __anonymous_object1805))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1806))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1807))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1808))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1809))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1810))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1811, const char *__anonymous_object1812))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1813))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1814, const char *__anonymous_object1815))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1816))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1817))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1818, const char *__anonymous_object1819, unsigned long int __anonymous_object1820))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1821, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret13=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(((_Bool (*)(void *__anonymous_object1822))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1823))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1824, _Bool __anonymous_object1825))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1826))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1827, const char *__anonymous_object1828))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1829))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1830, _Bool __anonymous_object1831))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1832))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1833))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1834))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1835))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1836))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1837, const char *__anonymous_object1838))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1839))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1840, const char *__anonymous_object1841))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1842))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1843))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1844, const char *__anonymous_object1845, unsigned long int __anonymous_object1846))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1847, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1848))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1849))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1850, _Bool __anonymous_object1851))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1852))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1853, const char *__anonymous_object1854))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1855))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1856, _Bool __anonymous_object1857))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1858))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1859))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1861))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1862))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1863, const char *__anonymous_object1864))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1865))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1866, const char *__anonymous_object1867))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1868))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1869))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1870, const char *__anonymous_object1871, unsigned long int __anonymous_object1872))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1873, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret12)), __v__Us_1)))) , _tmp_cp_ret13)), ((void *(*)(void *__anonymous_object1874))(&_thunk4)))))) , _tmp_cp_ret14)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1799))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1800))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1801, _Bool __anonymous_object1802))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1803))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1804, const char *__anonymous_object1805))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1806))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1807, _Bool __anonymous_object1808))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1809))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1810))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1811))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1812))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1813))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1814, const char *__anonymous_object1815))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1816))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1817, const char *__anonymous_object1818))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1819))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1820))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1821, const char *__anonymous_object1822, unsigned long int __anonymous_object1823))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1824, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret14=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1825))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1826))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1827, _Bool __anonymous_object1828))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1829))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1830, const char *__anonymous_object1831))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1832))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1833, _Bool __anonymous_object1834))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1835))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1836))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1837))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1838))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1839))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1840, const char *__anonymous_object1841))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1842))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1843, const char *__anonymous_object1844))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1845))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1846))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1847, const char *__anonymous_object1848, unsigned long int __anonymous_object1849))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1850, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret13=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(((_Bool (*)(void *__anonymous_object1851))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1852))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1853, _Bool __anonymous_object1854))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1855))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1856, const char *__anonymous_object1857))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1858))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1859, _Bool __anonymous_object1860))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1861))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1862))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1863))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1864))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1865))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1866, const char *__anonymous_object1867))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1868))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1869, const char *__anonymous_object1870))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1871))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1872))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1873, const char *__anonymous_object1874, unsigned long int __anonymous_object1875))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1876, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1877))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1878))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1879, _Bool __anonymous_object1880))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1881))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1882, const char *__anonymous_object1883))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1884))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1885, _Bool __anonymous_object1886))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1887))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1888))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1889))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1890))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1891))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1892, const char *__anonymous_object1893))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1894))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1895, const char *__anonymous_object1896))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1897))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1898))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1899, const char *__anonymous_object1900, unsigned long int __anonymous_object1901))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1902, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret12)), __v__Us_1)))) , _tmp_cp_ret13)), ((void *(*)(void *__anonymous_object1903))(&_thunk4)))))) , _tmp_cp_ret14)); } void __f__F_Ui__1(unsigned int __v__Ui_1){ @@ -513,7 +516,7 @@ struct ofstream *_tmp_cp_ret17; __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){ - return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1875))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1876))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1877, _Bool __anonymous_object1878))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1879))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1880, const char *__anonymous_object1881))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1882))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1883, _Bool __anonymous_object1884))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1885))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1886))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1887))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1888))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1889))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1890, const char *__anonymous_object1891))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1892))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1893, const char *__anonymous_object1894))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1895))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1896))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1897, const char *__anonymous_object1898, unsigned long int __anonymous_object1899))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1900, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); - } - ((void)(((void)(_tmp_cp_ret17=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1901))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1902))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1903, _Bool __anonymous_object1904))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1905))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1906, const char *__anonymous_object1907))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1908))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1909, _Bool __anonymous_object1910))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1911))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1912))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1913))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1914))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1915))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1916, const char *__anonymous_object1917))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1918))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1919, const char *__anonymous_object1920))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1921))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1922))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1923, const char *__anonymous_object1924, unsigned long int __anonymous_object1925))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1926, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret16=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ui__1(((_Bool (*)(void *__anonymous_object1927))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1928))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1929, _Bool __anonymous_object1930))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1931))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1932, const char *__anonymous_object1933))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1934))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1935, _Bool __anonymous_object1936))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1937))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1938))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1939))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1940))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1941))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1942, const char *__anonymous_object1943))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1944))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1945, const char *__anonymous_object1946))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1947))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1948))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1949, const char *__anonymous_object1950, unsigned long int __anonymous_object1951))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1952, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1953))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1954))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1955, _Bool __anonymous_object1956))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1957))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1958, const char *__anonymous_object1959))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1960))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1961, _Bool __anonymous_object1962))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1963))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1964))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1965))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1966))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1967))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1968, const char *__anonymous_object1969))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1970))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1971, const char *__anonymous_object1972))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1973))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1974))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1975, const char *__anonymous_object1976, unsigned long int __anonymous_object1977))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1978, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret15)), __v__Ui_1)))) , _tmp_cp_ret16)), ((void *(*)(void *__anonymous_object1979))(&_thunk5)))))) , _tmp_cp_ret17)); + return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1904))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1905))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1906, _Bool __anonymous_object1907))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1908))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1909, const char *__anonymous_object1910))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1911))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1912, _Bool __anonymous_object1913))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1914))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1915))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1916))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1917))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1918))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1919, const char *__anonymous_object1920))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1921))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1922, const char *__anonymous_object1923))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1924))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1925))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1926, const char *__anonymous_object1927, unsigned long int __anonymous_object1928))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1929, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0)); + } + ((void)(((void)(_tmp_cp_ret17=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1930))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1931))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1932, _Bool __anonymous_object1933))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1934))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1935, const char *__anonymous_object1936))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1937))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1938, _Bool __anonymous_object1939))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1940))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1941))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1942))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1943))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1944))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1945, const char *__anonymous_object1946))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1947))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1948, const char *__anonymous_object1949))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1950))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1951))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1952, const char *__anonymous_object1953, unsigned long int __anonymous_object1954))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1955, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret16=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ui__1(((_Bool (*)(void *__anonymous_object1956))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1957))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1958, _Bool __anonymous_object1959))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1960))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1961, const char *__anonymous_object1962))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1963))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1964, _Bool __anonymous_object1965))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1966))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1967))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1968))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1969))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1970))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1971, const char *__anonymous_object1972))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1973))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1974, const char *__anonymous_object1975))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1976))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1977))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1978, const char *__anonymous_object1979, unsigned long int __anonymous_object1980))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1981, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1982))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1983))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1984, _Bool __anonymous_object1985))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1986))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1987, const char *__anonymous_object1988))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1989))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1990, _Bool __anonymous_object1991))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1992))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1993))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1994))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1995))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1996))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1997, const char *__anonymous_object1998))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1999))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2000, const char *__anonymous_object2001))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object2002))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object2003))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object2004, const char *__anonymous_object2005, unsigned long int __anonymous_object2006))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object2007, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret15)), __v__Ui_1)))) , _tmp_cp_ret16)), ((void *(*)(void *__anonymous_object2008))(&_thunk5)))))) , _tmp_cp_ret17)); } signed int __main__Fi___1(){ Index: src/tests/.expect/memberCtors-ERR1.txt =================================================================== --- src/tests/.expect/memberCtors-ERR1.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,1 +1,0 @@ -memberCtors.c:71:1 error: in void ?{}(B &b), field a2 used before being constructed Index: src/tests/.expect/memberCtors.txt =================================================================== --- src/tests/.expect/memberCtors.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,213 +1,0 @@ -Before declaration of b1 -constructing int -constructing int -constructing int -constructing int -constructing int -constructing int -begin construct B -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 -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -end copy construct A -begin ?=? A -copy constructing int: 1001 -destructing int: 1001 -destructing int: 1001 -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -end ?=? 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 -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 -assigning int: 0 0 -end construct A -end construct B -destructing int: 0 -destructing int: 0 -destructing int: 1001 -Before declaration of b2 -copy constructing int: 0 -copy constructing int: 0 -begin copy construct A -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 -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -end copy construct A -End of main -constructing int -constructing int -begin construct A -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 -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -end copy construct A -begin ?=? A -copy constructing int: 999 -destructing int: 999 -destructing int: 999 -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -end ?=? 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 -destructing int: 0 -end copy construct A -destructing int: 0 -destructing int: 0 -destructing int: 999 -destructing int: 0 -destructing int: 0 -destructing int: 999 -destructing int: 0 -destructing int: 0 -destructing int: 1000 -destructing int: 0 -destructing int: 0 -destructing int: 999 -destructing int: 0 -destructing int: 0 -destructing int: 0 -destructing int: 0 -destructing int: 0 -destructing int: 999 -constructing int -constructing int -begin construct A -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 -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -end copy construct A -begin ?=? A -copy constructing int: 999 -destructing int: 999 -destructing int: 999 -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -copy constructing int: 0 -destructing int: 0 -destructing int: 0 -end ?=? 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 -destructing int: 0 -end copy construct A -destructing int: 0 -destructing int: 0 -destructing int: 999 -destructing int: 0 -destructing int: 0 -destructing int: 999 -destructing int: 0 -destructing int: 0 -destructing int: 1000 -destructing int: 0 -destructing int: 0 -destructing int: 999 -destructing int: 0 -destructing int: 0 -destructing int: 0 -destructing int: 0 -destructing int: 0 -destructing int: 999 Index: src/tests/.expect/multiDimension.txt =================================================================== --- src/tests/.expect/multiDimension.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,304 +1,0 @@ -constructing with 1 -constructing with 2 -constructing with 3 -constructing with 4 -constructing with 5 -constructing with 6 -constructing with 7 -constructing with 8 -constructing with 9 -constructing with 10 -constructing with 1 -constructing with 2 -constructing with 3 -constructing with 4 -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -constructing with 1234567 -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -constructing with 1 -constructing with 2 -constructing with 3 -constructing with 4 -constructing with 5 -constructing with 6 -constructing with 7 -constructing with 8 -constructing with 9 -constructing with 0 -constructing with 0 -constructing with 0 -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -default constructing -constructing with 999 -constructing with 1111 -default constructing -default constructing -constructing with 1 -constructing with 2 -constructing with 3 -constructing with 4 -default constructing -default constructing -default constructing -default constructing -constructing with 0 -default constructing -default constructing -default constructing -constructing with 11 -constructing with 22 -constructing with 33 -constructing with 55 -constructing with 66 -default constructing -constructing with 77 -default constructing -default constructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing -destructing Index: src/tests/.expect/sum.txt =================================================================== --- src/tests/.expect/sum.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/.expect/sum.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -4,2 +4,3 @@ sum from 0.5 to 1.5 is 9.5, check 9.5 sum from 5 to 15 is 95 95, check 95 95 +sum from 5 to 15 is 95, check 95 Index: src/tests/.expect/vector.txt =================================================================== --- src/tests/.expect/vector.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/.expect/vector.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,5 @@ +0 +1 +2 +3 +0 Index: src/tests/.expect/vector_test.txt =================================================================== --- src/tests/.expect/vector_test.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,5 +1,0 @@ -enter N elements and C-d on a separate line: -Array elements: -1 2 3 4 5 -Array elements reversed: -5 4 3 2 1 Index: src/tests/.in/vector_test.txt =================================================================== --- src/tests/.in/vector_test.txt (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,1 +1,0 @@ -1 2 3 4 5 Index: src/tests/Makefile.am =================================================================== --- src/tests/Makefile.am (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/Makefile.am (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -17,5 +17,5 @@ debug=yes -quick_test=vector_test avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes +quick_test=avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes if BUILD_CONCURRENCY @@ -44,11 +44,8 @@ .PHONY : list -EXTRA_PROGRAMS = fstream_test vector_test avl_test # build but do not install +EXTRA_PROGRAMS = fstream_test avl_test # build but do not install fstream_test_SOURCES = fstream_test.c fstream_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS} - -vector_test_SOURCES = vector/vector_int.c vector/array.c vector/vector_test.c -vector_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS} avl_test_SOURCES = avltree/avl_test.c avltree/avl0.c avltree/avl1.c avltree/avl2.c avltree/avl3.c avltree/avl4.c avltree/avl-private.c @@ -76,10 +73,4 @@ % : %.c @CFA_BINDIR@/@CFA_NAME@ ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@} - -dtor-early-exit-ERR1: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ - ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} - -dtor-early-exit-ERR2: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ - ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@} declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@ @@ -110,10 +101,4 @@ ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@} -memberCtors-ERR1: memberCtors.c @CFA_BINDIR@/@CFA_NAME@ - ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} - -ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@ - ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} - completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@ ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} @@ -124,2 +109,16 @@ alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@ ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} + +# Constructor/destructor tests +raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} + +raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@} + +raii/memberCtors-ERR1: raii/memberCtors.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} + +raii/ctor-autogen-ERR1: raii/ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} + Index: src/tests/Makefile.in =================================================================== --- src/tests/Makefile.in (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/Makefile.in (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -94,6 +94,5 @@ @BUILD_DEBUG_TRUE@@BUILD_RELEASE_FALSE@am__append_2 = -debug @BUILD_DEBUG_TRUE@@BUILD_RELEASE_TRUE@am__append_3 = ${DEBUG_FLAGS} -EXTRA_PROGRAMS = fstream_test$(EXEEXT) vector_test$(EXEEXT) \ - avl_test$(EXEEXT) +EXTRA_PROGRAMS = fstream_test$(EXEEXT) avl_test$(EXEEXT) subdir = src/tests ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 @@ -122,11 +121,4 @@ fstream_test_LDADD = $(LDADD) fstream_test_LINK = $(CCLD) $(fstream_test_CFLAGS) $(CFLAGS) \ - $(AM_LDFLAGS) $(LDFLAGS) -o $@ -am_vector_test_OBJECTS = vector/vector_test-vector_int.$(OBJEXT) \ - vector/vector_test-array.$(OBJEXT) \ - vector/vector_test-vector_test.$(OBJEXT) -vector_test_OBJECTS = $(am_vector_test_OBJECTS) -vector_test_LDADD = $(LDADD) -vector_test_LINK = $(CCLD) $(vector_test_CFLAGS) $(CFLAGS) \ $(AM_LDFLAGS) $(LDFLAGS) -o $@ AM_V_P = $(am__v_P_@AM_V@) @@ -162,8 +154,6 @@ am__v_CCLD_0 = @echo " CCLD " $@; am__v_CCLD_1 = -SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) \ - $(vector_test_SOURCES) -DIST_SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) \ - $(vector_test_SOURCES) +SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) +DIST_SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ @@ -313,5 +303,5 @@ top_srcdir = @top_srcdir@ debug = yes -quick_test = vector_test avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes +quick_test = avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes @BUILD_CONCURRENCY_FALSE@concurrent = '-Econcurrent' @BUILD_CONCURRENCY_TRUE@concurrent = @@ -325,6 +315,4 @@ fstream_test_SOURCES = fstream_test.c fstream_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS} -vector_test_SOURCES = vector/vector_int.c vector/array.c vector/vector_test.c -vector_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS} avl_test_SOURCES = avltree/avl_test.c avltree/avl0.c avltree/avl1.c avltree/avl2.c avltree/avl3.c avltree/avl4.c avltree/avl-private.c avl_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS} @@ -390,25 +378,8 @@ @rm -f fstream_test$(EXEEXT) $(AM_V_CCLD)$(fstream_test_LINK) $(fstream_test_OBJECTS) $(fstream_test_LDADD) $(LIBS) -vector/$(am__dirstamp): - @$(MKDIR_P) vector - @: > vector/$(am__dirstamp) -vector/$(DEPDIR)/$(am__dirstamp): - @$(MKDIR_P) vector/$(DEPDIR) - @: > vector/$(DEPDIR)/$(am__dirstamp) -vector/vector_test-vector_int.$(OBJEXT): vector/$(am__dirstamp) \ - vector/$(DEPDIR)/$(am__dirstamp) -vector/vector_test-array.$(OBJEXT): vector/$(am__dirstamp) \ - vector/$(DEPDIR)/$(am__dirstamp) -vector/vector_test-vector_test.$(OBJEXT): vector/$(am__dirstamp) \ - vector/$(DEPDIR)/$(am__dirstamp) - -vector_test$(EXEEXT): $(vector_test_OBJECTS) $(vector_test_DEPENDENCIES) $(EXTRA_vector_test_DEPENDENCIES) - @rm -f vector_test$(EXEEXT) - $(AM_V_CCLD)$(vector_test_LINK) $(vector_test_OBJECTS) $(vector_test_LDADD) $(LIBS) mostlyclean-compile: -rm -f *.$(OBJEXT) -rm -f avltree/*.$(OBJEXT) - -rm -f vector/*.$(OBJEXT) distclean-compile: @@ -423,7 +394,4 @@ @AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl_test-avl4.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl_test-avl_test.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@vector/$(DEPDIR)/vector_test-array.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@vector/$(DEPDIR)/vector_test-vector_int.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@vector/$(DEPDIR)/vector_test-vector_test.Po@am__quote@ .c.o: @@ -554,46 +522,4 @@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(fstream_test_CFLAGS) $(CFLAGS) -c -o fstream_test-fstream_test.obj `if test -f 'fstream_test.c'; then $(CYGPATH_W) 'fstream_test.c'; else $(CYGPATH_W) '$(srcdir)/fstream_test.c'; fi` - -vector/vector_test-vector_int.o: vector/vector_int.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-vector_int.o -MD -MP -MF vector/$(DEPDIR)/vector_test-vector_int.Tpo -c -o vector/vector_test-vector_int.o `test -f 'vector/vector_int.c' || echo '$(srcdir)/'`vector/vector_int.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_int.Tpo vector/$(DEPDIR)/vector_test-vector_int.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/vector_int.c' object='vector/vector_test-vector_int.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-vector_int.o `test -f 'vector/vector_int.c' || echo '$(srcdir)/'`vector/vector_int.c - -vector/vector_test-vector_int.obj: vector/vector_int.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-vector_int.obj -MD -MP -MF vector/$(DEPDIR)/vector_test-vector_int.Tpo -c -o vector/vector_test-vector_int.obj `if test -f 'vector/vector_int.c'; then $(CYGPATH_W) 'vector/vector_int.c'; else $(CYGPATH_W) '$(srcdir)/vector/vector_int.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_int.Tpo vector/$(DEPDIR)/vector_test-vector_int.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/vector_int.c' object='vector/vector_test-vector_int.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-vector_int.obj `if test -f 'vector/vector_int.c'; then $(CYGPATH_W) 'vector/vector_int.c'; else $(CYGPATH_W) '$(srcdir)/vector/vector_int.c'; fi` - -vector/vector_test-array.o: vector/array.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-array.o -MD -MP -MF vector/$(DEPDIR)/vector_test-array.Tpo -c -o vector/vector_test-array.o `test -f 'vector/array.c' || echo '$(srcdir)/'`vector/array.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-array.Tpo vector/$(DEPDIR)/vector_test-array.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/array.c' object='vector/vector_test-array.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-array.o `test -f 'vector/array.c' || echo '$(srcdir)/'`vector/array.c - -vector/vector_test-array.obj: vector/array.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-array.obj -MD -MP -MF vector/$(DEPDIR)/vector_test-array.Tpo -c -o vector/vector_test-array.obj `if test -f 'vector/array.c'; then $(CYGPATH_W) 'vector/array.c'; else $(CYGPATH_W) '$(srcdir)/vector/array.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-array.Tpo vector/$(DEPDIR)/vector_test-array.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/array.c' object='vector/vector_test-array.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-array.obj `if test -f 'vector/array.c'; then $(CYGPATH_W) 'vector/array.c'; else $(CYGPATH_W) '$(srcdir)/vector/array.c'; fi` - -vector/vector_test-vector_test.o: vector/vector_test.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-vector_test.o -MD -MP -MF vector/$(DEPDIR)/vector_test-vector_test.Tpo -c -o vector/vector_test-vector_test.o `test -f 'vector/vector_test.c' || echo '$(srcdir)/'`vector/vector_test.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_test.Tpo vector/$(DEPDIR)/vector_test-vector_test.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/vector_test.c' object='vector/vector_test-vector_test.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-vector_test.o `test -f 'vector/vector_test.c' || echo '$(srcdir)/'`vector/vector_test.c - -vector/vector_test-vector_test.obj: vector/vector_test.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-vector_test.obj -MD -MP -MF vector/$(DEPDIR)/vector_test-vector_test.Tpo -c -o vector/vector_test-vector_test.obj `if test -f 'vector/vector_test.c'; then $(CYGPATH_W) 'vector/vector_test.c'; else $(CYGPATH_W) '$(srcdir)/vector/vector_test.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_test.Tpo vector/$(DEPDIR)/vector_test-vector_test.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/vector_test.c' object='vector/vector_test-vector_test.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-vector_test.obj `if test -f 'vector/vector_test.c'; then $(CYGPATH_W) 'vector/vector_test.c'; else $(CYGPATH_W) '$(srcdir)/vector/vector_test.c'; fi` ID: $(am__tagged_files) @@ -711,6 +637,4 @@ -rm -f avltree/$(DEPDIR)/$(am__dirstamp) -rm -f avltree/$(am__dirstamp) - -rm -f vector/$(DEPDIR)/$(am__dirstamp) - -rm -f vector/$(am__dirstamp) maintainer-clean-generic: @@ -722,5 +646,5 @@ distclean: distclean-am - -rm -rf ./$(DEPDIR) avltree/$(DEPDIR) vector/$(DEPDIR) + -rm -rf ./$(DEPDIR) avltree/$(DEPDIR) -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ @@ -768,5 +692,5 @@ maintainer-clean: maintainer-clean-am - -rm -rf ./$(DEPDIR) avltree/$(DEPDIR) vector/$(DEPDIR) + -rm -rf ./$(DEPDIR) avltree/$(DEPDIR) -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic @@ -827,10 +751,4 @@ ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@} -dtor-early-exit-ERR1: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ - ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} - -dtor-early-exit-ERR2: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ - ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@} - declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@ ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@} @@ -860,10 +778,4 @@ ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@} -memberCtors-ERR1: memberCtors.c @CFA_BINDIR@/@CFA_NAME@ - ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} - -ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@ - ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} - completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@ ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} @@ -873,4 +785,17 @@ alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} + +# Constructor/destructor tests +raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} + +raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@} + +raii/memberCtors-ERR1: raii/memberCtors.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} + +raii/ctor-autogen-ERR1: raii/ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@ ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} Index: src/tests/alloc.c =================================================================== --- src/tests/alloc.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/alloc.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -10,6 +10,6 @@ // Created On : Wed Feb 3 07:56:22 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Nov 24 23:06:42 2017 -// Update Count : 319 +// Last Modified On : Mon Jan 22 21:26:40 2018 +// Update Count : 326 // @@ -32,10 +32,10 @@ // allocation, non-array types - // int &r = malloc(); + // int & r = malloc(); // r = 0xdeadbeef; // printf( "C malloc %#x\n", r ); // free( &r ); - p = (int *)(void *)malloc( sizeof(*p) ); // C malloc, type unsafe + p = (int *)malloc( sizeof(*p) ); // C malloc, type unsafe *p = 0xdeadbeef; printf( "C malloc %#x\n", *p ); @@ -88,5 +88,5 @@ printf( "\n" ); - p = (int *)(void *)realloc( p, dim * sizeof(*p) ); // C realloc + p = (int *)realloc( p, dim * sizeof(*p) ); // C realloc for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } printf( "C realloc\n" ); @@ -259,8 +259,9 @@ free( p ); +#ifdef ERR1 stp = malloc(); printf( "\nSHOULD FAIL\n" ); -#ifdef ERR1 - p = alloc( stp, dim * sizeof(*stp) ); + p = realloc( stp, dim * sizeof( *stp ) ); + p = alloc( stp, dim * sizeof( *stp ) ); p = memset( stp, 10 ); p = memcpy( &st1, &st ); Index: src/tests/concurrent/examples/.expect/quickSort.txt =================================================================== --- src/tests/concurrent/examples/.expect/quickSort.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/concurrent/examples/.expect/quickSort.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,32 @@ +25 6 8 -5 99 100 101 7 +-5 6 7 8 25 99 100 101 + +1 -3 5 +-3 1 5 + + + + +9 8 7 6 5 4 3 2 1 0 +0 1 2 3 4 5 6 7 8 9 + +1 2 3 4 5 +1 2 3 4 5 + +5 4 3 2 1 +1 2 3 4 5 + +3 1 5 4 2 +1 2 3 4 5 + + + + +1 1 1 1 1 +1 1 1 1 1 + +29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 + 7 6 5 4 3 2 1 0 +0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 + 22 23 24 25 26 27 28 29 + Index: src/tests/concurrent/examples/quickSort.c =================================================================== --- src/tests/concurrent/examples/quickSort.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/concurrent/examples/quickSort.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -1,15 +1,15 @@ -// +// // The contents of this file are covered under the licence agreement in the // file "LICENCE" distributed with Cforall. -// +// // quickSort.c -- In-place concurrent quick-sort: threads are created to partition to a specific depth, then sequential // recursive-calls are use to sort each partition. -// +// // Author : Peter A. Buhr // Created On : Wed Dec 6 12:15:52 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Dec 14 11:20:40 2017 -// Update Count : 142 -// +// Last Modified On : Mon Jan 29 08:41:37 2018 +// Update Count : 155 +// #include @@ -19,27 +19,24 @@ #include // strcmp -forall( otype T | { int ? 0 ) { depth -= 1; - //sout << &uThisTask() << " " << depth << endl; - Quicksort(T) rqs = { values, low, right, depth }; // concurrently sort upper half + Quicksort rqs = { values, low, right, depth }; // concurrently sort upper half //Quicksort lqs( values, left, high, depth ); // concurrently sort lower half sort( values, left, high, depth ); // concurrently sort lower half @@ -97,6 +93,4 @@ -#define ELEMTYPE int - int main( int argc, char * argv[] ) { ifstream & unsortedfile = sin; @@ -106,22 +100,7 @@ if ( argc != 1 ) { // do not use defaults if ( argc < 2 || argc > 4 ) usage( argv ); // wrong number of options - if ( strcmp( argv[1], "-s" ) == 0 ) { - choose ( argc ) { - case 4: - &sortedfile = new( (const char *)argv[3] ); // open the output file - if ( fail( sortedfile ) ) { - serr | "Error! Could not open sorted output file \"" | argv[3] | "\"" | endl; - usage( argv ); - } // if - fallthrough; - case 3: - &unsortedfile = new( (const char *)argv[2] ); // open the input file - if ( fail( unsortedfile ) ) { - serr | "Error! Could not open unsorted input file \"" | argv[2] | "\"" | endl; - usage( argv ); - } // if - } // choose - } else if ( strcmp( argv[1], "-t" ) == 0 ) { - unsortedfile = *(ifstream *)0; // no input +// if ( strcmp( argv[1], "-t" ) == 0 ) { // timing ? + if ( argv[1][0] == '-' && argv[1][1] == 't' ) { // timing ? + &unsortedfile = (ifstream *)0; // no input choose ( argc ) { case 4: @@ -131,5 +110,21 @@ if ( ! convert( size, argv[2] ) || size < 0 ) usage( argv ); } // choose - } else usage( argv ); // invalid flag + } else { // sort file + choose ( argc ) { + case 3: + &sortedfile = new( (const char *)argv[2] ); // open the output file + if ( fail( sortedfile ) ) { + serr | "Error! Could not open sorted output file \"" | argv[2] | "\"" | endl; + usage( argv ); + } // if + fallthrough; + case 2: + &unsortedfile = new( (const char *)argv[1] ); // open the input file + if ( fail( unsortedfile ) ) { + serr | "Error! Could not open unsorted input file \"" | argv[1] | "\"" | endl; + usage( argv ); + } // if + } // choose + } // if } // if @@ -140,7 +135,5 @@ unsortedfile | size; // read number of elements in the list if ( eof( unsortedfile ) ) break; -// ELEMTYPE * values = anew( size ); // values to be sorted, too large to put on stack - ELEMTYPE * values = alloc( size ); // values to be sorted, too large to put on stack -// ELEMTYPE * values = (ELEMTYPE *)malloc( sizeof(ELEMTYPE) * size ); + int * values = alloc( size ); // values to be sorted, too large to put on stack for ( int counter = 0; counter < size; counter += 1 ) { // read unsorted numbers unsortedfile | values[counter]; @@ -151,5 +144,5 @@ sortedfile | endl; if ( size > 0 ) { // values to sort ? - Quicksort(ELEMTYPE) QS = { values, size - 1, 0 }; // sort values + Quicksort QS = { values, size - 1, 0 }; // sort values } // wait until sort tasks terminate for ( int counter = 0; counter < size; counter += 1 ) { // print sorted list @@ -167,11 +160,10 @@ processor processors[ (1 << depth) - 1 ] __attribute__(( unused )); // create 2^depth-1 kernel threads -// ELEMTYPE * values = anew( size ); // values to be sorted, too large to put on stack - ELEMTYPE * values = alloc( size ); // values to be sorted, too large to put on stack + int * values = alloc( size ); // values to be sorted, too large to put on stack for ( int counter = 0; counter < size; counter += 1 ) { // generate unsorted numbers values[counter] = size - counter; // descending values } // for { - Quicksort(ELEMTYPE) QS = { values, size - 1, depth }; // sort values + Quicksort QS = { values, size - 1, depth }; // sort values } // wait until sort tasks terminate Index: src/tests/ctor-autogen.c =================================================================== --- src/tests/ctor-autogen.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,153 +1,0 @@ -// TODO: add error cases (e.g., use of field constructors for managed types, etc.) - -enum Color { R, G, B }; - -// empty struct/union should have generated ctor/dtors -union U {}; -struct S {}; - -struct SimpleUnion { - int x; - double y; - char z; -}; - -struct SimpleStruct { - int x; - double y; - char z; -}; - -// struct/union with members with generated ctor/dtors should themselves have generated ctor/dtors -union PopulatedUnion { - Color c; - U u; - S s; -}; - -struct PopulatedStruct { - Color c; - U u; - S s; -}; - -// dtype-static generic type is otype -forall(dtype T) -struct DtypeStaticStruct { - T * data; - short size; -}; - -forall(dtype T) -union DtypeStaticUnion { - T * data; - short size; -}; - -// dynamic generic type is otype -forall(otype T) -struct DynamicStruct { - T x; -}; - -forall(otype T) -union DynamicUnion { - T x; -}; - -// struct/union that contains a generic type is -struct GenericContainingStruct { - DynamicStruct(int) dsi; - DynamicStruct(double) dsd; - DynamicUnion(int) dui; - DynamicUnion(double) dud; - DtypeStaticStruct(int) dssi; - DtypeStaticStruct(float) dssf; - DtypeStaticUnion(int) dsui; - DtypeStaticUnion(float) dsuf; -}; - -union GenericContainingUnion { - DynamicStruct(int) dsi; - DynamicStruct(double) dsd; - DynamicUnion(int) dui; - DynamicUnion(double) dud; - DtypeStaticStruct(int) dssi; - DtypeStaticStruct(float) dssf; - DtypeStaticUnion(int) dsui; - DtypeStaticUnion(float) dsuf; -}; - - -forall(otype T) -T identity(T x) { return x; } - -// can identity e if only sized or only the assertion, but the combination breaks... -// forall(dtype T | sized(T) | { void ?{}(T &); }) -// void identity(T x) { } - -#if ERR1 -// managed type - defines a constructor - can't use field constructors -struct Managed { - int x; -}; - -void ?{}(Managed & m) { m.x = 0; } - -// managed type since it contains a managed type - can't use field constructors -struct InheritManaged { - Managed m; -}; - -Managed x = { 123 }; // error -Managed y; // okay - -InheritManaged z = { y }; // error? -#endif - -int main() { - S s; - U u; - Color e; - - // identity(R); Color constant should be Color which is otype - identity(e); // Color should be an otype - identity(u); // U should be an otype - identity(s); // S should be an otype - - SimpleStruct ss; - SimpleUnion su; - - identity(ss); - identity(su); - - PopulatedStruct ps; - PopulatedUnion pu; - - identity(ps); // should recursively be an otype - identity(pu); // should recursively be an otype - - DynamicStruct(int) dsi; - DynamicStruct(double) dsd; - DynamicUnion(int) dui; - DynamicUnion(double) dud; - DtypeStaticStruct(int) dssi; - DtypeStaticStruct(float) dssf; - DtypeStaticUnion(int) dsui; - DtypeStaticUnion(float) dsuf; - - identity(dsi); - identity(dsd); - // identity(dui); // xxx - codegen errors in generated thunk _temp3 (Box-pass-generated assignment return-temporary) - // identity(dud); - identity(dssi); - identity(dssf); - identity(dsui); - identity(dsuf); - - GenericContainingStruct gcs; - GenericContainingUnion gcu; - - identity(gcs); - identity(gcu); -} Index: src/tests/dtor-early-exit.c =================================================================== --- src/tests/dtor-early-exit.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,256 +1,0 @@ -// -// 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. -// -// dtor-early-exit.c -- -// -// Author : Rob Schluntz -// Created On : Wed Aug 17 08:26:25 2016 -// Last Modified By : Peter A. Buhr -// Last Modified On : Wed Aug 17 08:29:37 2016 -// Update Count : 2 -// - -#include -#include -extern "C" { -#define false ((int)0) // until stdbool.h works -#define assert(cond) if (! (cond)) { sout | "Assertion failed: (" | #cond | ") at " __FILE__ | ":" | __LINE__ | endl; abort(); } -} - -struct A { - const char * name; - int * x; -}; - -// 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 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 -void f(int i) { - sout | "f i=" | i | endl; - A x = { "x" }; // construct x - { - A y = { "y" }; // construct y - { - A z = { "z" }; // construct z - { - if (i == 0) return; // destruct x, y, z - } - if (i == 1) return; // destruct x, y, z - // destruct z - } - if (i == 2) return; // destruct x, y - // destruct y - } - return; // destruct x -} - -// test loops, switch, etc. -void g() { - for (int i = 0; i < 10; i++) { - sout | "g for i=" | i | endl; - A x = { "x" }; - // construct x - // destruct x - } - sout | endl; - { - int i = 0; - while (i < 10) { - sout | "g while i=" | i | endl; - A x = { "x" }; - // construct x - i++; - // destruct x - } - } - sout | endl; - for (int i = 0; i < 10; i++) { - switch(10) { - case 0: - case 5: - case 10: { - A y = { "y" }; - sout | "g switch i=" | i | endl; - // construct y - break; // destruct y - } - default: { - sout | "g switch i=" | i | endl; - A x = { "x" }; - // construct x - break; // destruct x - } - } - } - sout | endl; - for (int k = 0; k < 2; k++) { - sout | "g for k=" | k | endl; - L1: for (int i = 0; i < 10; i++) { - sout | "g for i=" | i | endl; - - A x = { "x" }; - if (i == 2) { - sout | "continue L1" | endl; - continue; // destruct x - } else if (i == 3) { - sout | "break L1" | endl; - break; // destruct x - } - - L2: for (int j = 0; j < 10; j++) { - sout | "g for j=" | j | endl; - A y = { "y" }; - if (j == 0) { - sout | "continue L2" | endl; - continue; // destruct y - missing because object that needs to be destructed is not a part of this block, it's a part of the for's block - } else if (j == 1) { - sout | "break L2" | endl; - break; // destruct y - } else if (i == 1) { - sout | "continue L1" | endl; - continue L1; // destruct x,y - note: continue takes you to destructors for block, so only generate destructor for y - } else if (k == 1) { - sout | "break L1" | endl; - break L1; // destruct x,y - } - } - } - } - - sout | endl; - L3: if( 3 ) { - A w = { "w" }; - if( 4 ) { - A v = { "v" }; - sout | "break L3" | endl; - break L3; - } - } -} - -// test goto -void h() { - int i = 0; - // for each goto G with target label L: - // * find all constructed variables alive at G (set S_G) - // * find all constructed variables alive at L (set S_L) - // * if S_L-S_G is non-empty, error - // * emit destructors for all variables in S_G-S_L - sout | "h" | endl; - { - L0: ; -#ifdef ERR1 - goto L1; // this is an error in g++ because it skips initialization of y -#endif - A y = { "y" }; - // S_L1 = { y } - L1: sout | "L1" | endl; - A x = { "x" }; - // S_L2 = { y, x } - L2: sout | "L2" | endl; - if (i == 0) { - ++i; - sout | "goto L1" | endl; - // S_G = { y, x } - goto L1; // jump back, destruct b/c before x definition - // S_L-S_G = {} => no error - // S_G-S_L = { x } => destruct x - } else if (i == 1) { - ++i; - sout | "goto L2" | endl; - // S_G = { y, x } - goto L2; // jump back, do not destruct - // S_L-S_G = {} - // S_G-S_L = {} => destruct nothing - } else if (i == 2) { - ++i; - sout | "goto L3" | endl; - // S_G = { y, x } - goto L3; // jump ahead, do not destruct - // S_L-S_G = {} - // S_G-S_L = {} - } else if (false) { - ++i; - A z = { "z" }; - sout | "goto L3-2" | endl; - // S_G = { z, y, x } - goto L3; - // S_L-S_G = {} - // S_G-S_L = {z} => destruct z - } else { - ++i; - sout | "goto L4" | endl; - // S_G = { y, x } - goto L4; // jump ahead, destruct b/c left block x was defined in - // S_L-S_G = {} - // S_G-S_L = { y, x } => destruct y, x - } - // S_L3 = { y, x } - L3: sout | "L3" | endl; - sout | "goto L2-2" | endl; - // S_G = { y, x } - goto L2; // jump back, do not destruct - // S_L-S_G = {} - // S_G-S_L = {} - } - // S_L4 = {} - L4: sout | "L4" | endl; - if (i == 4) { - sout | "goto L0" | endl; - // S_G = {} - goto L0; - // S_L-S_G = {} - // S_G-S_L = {} - } -#ifdef ERR2 - // S_G = {} - if (i == 5) goto L2; // this is an error in g++ because it skips initialization of y, x - // S_L-S_G = { y, x } => non-empty, so error -#endif -} - -// TODO: implement __label__ and uncomment these lines -void computedGoto() { - // __label__ bar; - void *ptr; - ptr = &&foo; - goto *ptr; - assert(false); -foo: ; -// void f() { -// ptr = &&bar; -// goto *ptr; -// assert(false); -// } -// f(); -// assert(false); -// bar: ; -} - -int main() { - sepDisable(sout); - for (int i = 0; i < 4; i++) { - f(i); - } - sout | endl; - g(); - sout | endl; - h(); - - computedGoto(); -} - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa dtor-early-exit" // -// End: // Index: src/tests/globals.c =================================================================== --- src/tests/globals.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,83 +1,0 @@ -#include - -struct value_t { - int value; -}; - -void ?{}( value_t & this ) { this.value = 22; } - -//Standard case -struct g_t { - value_t val; -}; - -void ?{}( g_t & this ) { (this.val){}; } - -g_t g; - -//Autogen case -struct ga_t { - value_t val; -}; - -ga_t ga; - -//Inline case -struct gi_t; -void ?{}( gi_t & this ); - -struct gi_t { - value_t val; -} gi; - -void ?{}( gi_t & this ) { (this.val){}; } - -//Inline autogen case -struct gia_t { - value_t val; -} gia; - -//Static case -struct gs_t { - value_t val; -}; - -void ?{}( gs_t & this ) { (this.val){}; } - -static gs_t gs; - -//Static autogen case -struct gsa_t { - value_t val; -}; - -static gsa_t gsa; - -//Static inline case -struct gsi_t; -void ?{}( gsi_t & this ); - -static struct gsi_t { - value_t val; -} gsi; - -void ?{}( gsi_t & this ) { (this.val){}; } - -//Static inline autogen case -static struct gsia_t { - value_t val; -} gsia; - -int main() { - sout | "static\t\tinline\t\tautogen\t\tvalue" | endl; - - sout | "no \t\tno \t\tno \t\t" | g.val.value | endl; - sout | "no \t\tno \t\tyes\t\t" | ga.val.value | endl; - sout | "no \t\tyes\t\tno \t\t" | gi.val.value | endl; - sout | "no \t\tyes\t\tyes\t\t" | gia.val.value | endl; - sout | "yes\t\tno \t\tno \t\t" | gs.val.value | endl; - sout | "yes\t\tno \t\tyes\t\t" | gsa.val.value | endl; - sout | "yes\t\tyes\t\tno \t\t" | gsi.val.value | endl; - sout | "yes\t\tyes\t\tyes\t\t" | gsia.val.value | endl; - -} Index: src/tests/init_once.c =================================================================== --- src/tests/init_once.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,195 +1,0 @@ -// -// 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. -// -// init_once.c -- -// -// Author : Rob Schluntz -// Created On : Tue Jun 14 15:43:35 2016 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 9 11:30:29 2016 -// Update Count : 3 -// - -// want to ensure ctor/dtor called at most once per object. -// whole point of ctor/dtor is that you don't know what's in -// memory when it's first called, so can't rely on member to -// determine if this is true. instead, keep an array -// of addresses that have been constructed and remove the element -// when it's destructed (and vice-versa) - -//*** setup -extern "C" { -#define NULL 0 -void * malloc(size_t); -void free(void *); -#define assert(cond) if (! (cond)) { printf("Assertion failed: (%s) at %s:%d\n", #cond, __FILE__, __LINE__); abort(); } -void *memset(void *s, int c, size_t n); -} - -// dummy type -struct init_once { int * x; }; - -// array and operations -// const int size = 1024; -#define size 1024 -struct array { - init_once * elems[size]; - int length; -}; -void remove(array * arr, init_once * x) { - for (int i = 0; i < arr->length; i++) { - if ( arr->elems[i] == x ) { - arr->elems[i] = arr->elems[--arr->length]; - return; - } - } -} -void insert(array * arr, init_once * x) { - assert( arr->length < size ); - arr->elems[arr->length++] = x; -} -int find(array * arr, init_once * x) { - for (int i = 0; i < arr->length; i++) { - if ( arr->elems[i] == x ) { - return i; - } - } - return -1; -} -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 ); - - x.x = (int *)malloc(sizeof(int)); -} - -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 ); - - free(x.x); -} -//*** end setup - -// test globals -init_once x; -init_once y = x; - -void static_variable() { - static init_once x; -} - -int main() { - // local variables - init_once x; - init_once y = x; - - // block scoped variables - { - init_once x; - init_once y = x; - } - - // loop variables - for (int i = 0 ; i < 10; i++) { - init_once x; - init_once y = x; - } - int i = 0; - while (i < 10) { - init_once x; - init_once y = x; - i++; - } - - // declared in a switch block with a break - for (int i = 0; i < 10; i++) { - switch (10) { - case 1: { - init_once x; - init_once y = x; - x{}; // ensure this doesn't execute - break; - } - case 10: { - init_once x; - init_once y = x; - } // fall through - default: { - init_once x; - init_once y = x; - break; - } - } - } - - // labeled break/continue - L3: for (int k = 0; k < 10; k++) { - init_once x; - init_once y = x; - L1: for (int i = 0; i < 10; i++){ - init_once x; - init_once y = x; - L2: for (int j = 0; j < 10; j++) { - init_once x; - init_once y = x; - - if (i == 0) continue L1; - if (i == 1) continue L2; - if (i == 2) break L2; - if (i == 3) break L1; - if (i == 4) continue L3; - if (i == 9) break L3; - // if (i == 5) goto ; - } - } - } - - // labeled break/continue with if - LL1: for (int k = 0; k < 10; k++) { - init_once x; - init_once y = x; - LL2: for (int i = 0; i < 10; i++){ - init_once x; - init_once y = x; - LL3: if( i < 5) { - init_once x; - init_once y = x; - - if (i == 0) continue LL2; - if (i == 2) break LL3; - if (i == 3) break LL2; - if (i == 4) continue LL1; - } else { - if (i == 9) break LL1; - // if (i == 5) goto ; - } - } - } - - // function-scoped static variable - for (int i = 0; i < 10; i++) { - static_variable(); - } -} - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa init_once.c" // -// End: // Index: src/tests/io.c =================================================================== --- src/tests/io.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/io.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -10,6 +10,6 @@ // Created On : Wed Mar 2 16:56:02 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Dec 6 23:15:42 2017 -// Update Count : 88 +// Last Modified On : Fri Jan 26 15:19:34 2018 +// Update Count : 100 // @@ -17,5 +17,6 @@ int main() { - char c; // basic types + _Bool b; // basic types + char c; signed char sc; unsigned char usc; @@ -90,5 +91,6 @@ sout | "input bacis types" | endl; - in | c | sc | usc // character + in | b // boolean + | c | sc | usc // character | si | usi | i | ui | li | uli | lli | ulli // integral | f | d | ld // floating point @@ -98,5 +100,6 @@ sout | "output basic types" | endl; - sout | c | ' ' | sc | ' ' | usc | endl // character + sout | b | endl // boolean + | c | ' ' | sc | ' ' | usc | endl // character | si | usi | i | ui | li | uli | lli | ulli | endl // integral | f | d | ld | endl // floating point Index: src/tests/io.data =================================================================== --- src/tests/io.data (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/io.data (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -1,1 +1,1 @@ -A 23 93 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz +falseA 23 93 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz Index: src/tests/libcfa_vector.c =================================================================== --- src/tests/libcfa_vector.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,66 +1,0 @@ -// -// 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. -// -// libcfa_vector.c -- -// -// Author : Thierry Delisle -// Created On : Mon Jul 4 23:36:19 2016 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jul 5 15:08:05 2016 -// Update Count : 26 -// - -#include -#include - -#undef assert -#define assert(x) \ - do { \ - if ( !(x) ) { \ - sout | "CHECK failed :" | #x | "at" | __FILE__ | " :" | __LINE__ | endl; \ - abort(); \ - } \ - } while( 0 == 1 ) - -int main() { - vector( int ) iv; - - assert( empty( &iv ) ); - assert( size( &iv ) == 0 ); - sout | size( &iv ) | endl; - - push_back( &iv, 1 ); - assert( size( &iv ) == 1 ); - sout | size( &iv ) | endl; - - push_back( &iv, 2 ); - assert( size( &iv ) == 2 ); - sout | size( &iv ) | endl; - - push_back( &iv, 3 ); - assert( size( &iv ) == 3 ); - sout | size( &iv ) | endl; - - assert( !empty( &iv ) ); - assert( size( &iv ) == 3 ); - assert( at( &iv, 0 ) == 1 ); - assert( (&iv)[0] == 1 ); - assert( at( &iv, 1 ) == 2 ); - assert( (&iv)[1] == 2 ); - assert( at( &iv, 2 ) == 3 ); - assert( (&iv)[2] == 3 ); - - clear( &iv ); - - assert( empty( &iv ) ); - assert( size( &iv ) == 0 ); - sout | size( &iv ) | endl; -} - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa libcfa_vector.c" // -// End: // Index: src/tests/memberCtors.c =================================================================== --- src/tests/memberCtors.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,91 +1,0 @@ -struct WrappedInt { - int x; -}; - -void ?{}(WrappedInt & this) { - printf("constructing int\n"); - this.x = 0; -} - -void ?{}(WrappedInt & this, WrappedInt other) { - printf("copy constructing int: %d\n", other.x); - this.x = other.x; -} - -void ?{}(WrappedInt & this, int x) { - printf("constructing int: %d\n", x); - this.x = 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; -} - -struct A { - WrappedInt x, y, z; -}; - -void ?{}(A & a) { - // currently must define default ctor, since there's no "= default" syntax -} - -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("end construct A\n"); -} // z never constructed - will be automatically default constructed - -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("end copy construct A\n"); -} // z never constructed - will be automatically copy constructed - -A ?=?(A & this, A other) { - printf("begin ?=? A\n"); - this.x = other.x; - this.y = other.y; - this.z = other.z; - printf("end ?=? A\n"); - return this; -} - -struct B { - A a1, a2, a3; -}; - -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 }; -#ifdef ERR1 - (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){}; -} // a2, a3 never destructed - will be automatically destructed - -int main() { - printf("Before declaration of b1\n"); - B b1; - printf("Before declaration of b2\n"); - B b2 = b1; - printf("End of main\n"); -} Index: src/tests/multiDimension.c =================================================================== --- src/tests/multiDimension.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,75 +1,0 @@ -struct X { - int a; - int * ptr; -}; - -void ?{}(X & this) { - printf("default constructing\n"); - (this.a){ 123 }; - this.ptr = (int *)malloc(sizeof(int)); -} - -void ?{}(X & this, X other) { - printf("copy constructing\n"); - (this.a){ other.a }; - this.ptr = (int *)malloc(sizeof(int)); -} - -void ?{}(X & this, int a) { - printf("constructing with %d\n", a); - (this.a){ a }; - this.ptr = (int *)malloc(sizeof(int)); -} - -void ^?{}(X & this) { - printf("destructing\n"); - free(this.ptr); -} - -X ?=?(X & this, X other) { - this.a = other.a; - return this; -} - -X global[10][10] = { - { 1, { 2 }, { 3 }, { 4 }, 5, 6, 7, 8, 9, 10, 11, 12 }, - { 1, 2, 3, 4 }, - { { 1234567 } } -}; - -X global2[3][3][3] = { - { - { 1, 2, 3 }, - { 4, 5, 6 }, - { 7, 8, 9 }, - { 10, 11, 12 } - }, - { - { 0, 0, 0 } - } -}; - -int foo() { - static X abc[3][3] = { - { 11, 22, 33, 44 }, - { 55, 66 }, - { 77 }, - { 88, 99, 1010 } - }; -} - -// ensure constructed const arrays continue to compile -const int global[1] = { -2 }; - -int main() { - X abc[4][4] = { - { 999, 1111 }, - { 1, 2, 3, 4, 5 }, - {}, - { 0 }, - { 88 } - }; - - foo(); - foo(); -} Index: src/tests/raii/.expect/ctor-autogen-ERR1.txt =================================================================== --- src/tests/raii/.expect/ctor-autogen-ERR1.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/.expect/ctor-autogen-ERR1.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,9 @@ +raii/ctor-autogen.c:102:1 error: No reasonable alternatives for expression Applying untyped: + Name: ?{} +...to: + Cast of: + Variable Expression: x: instance of struct Managed with body 1 + ... to: + reference to instance of struct Managed with body 1 + constant expression (123 123: signed int) + Index: src/tests/raii/.expect/dtor-early-exit-ERR1.txt =================================================================== --- src/tests/raii/.expect/dtor-early-exit-ERR1.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/.expect/dtor-early-exit-ERR1.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,4 @@ +raii/dtor-early-exit.c:153:1 error: jump to label 'L1' crosses initialization of y Branch (Goto) + with target: L1 + with original target: L1 + Index: src/tests/raii/.expect/dtor-early-exit-ERR2.txt =================================================================== --- src/tests/raii/.expect/dtor-early-exit-ERR2.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/.expect/dtor-early-exit-ERR2.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,4 @@ +raii/dtor-early-exit.c:220:1 error: jump to label 'L2' crosses initialization of y Branch (Goto) + with target: L2 + with original target: L2 + Index: src/tests/raii/.expect/dtor-early-exit.txt =================================================================== --- src/tests/raii/.expect/dtor-early-exit.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/.expect/dtor-early-exit.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,220 @@ +f i=0 +construct x +construct y +construct z +destruct z +destruct y +destruct x +f i=1 +construct x +construct y +construct z +destruct z +destruct y +destruct x +f i=2 +construct x +construct y +construct z +destruct z +destruct y +destruct x +f i=3 +construct x +construct y +construct z +destruct z +destruct y +destruct x + +g for i=0 +construct x +destruct x +g for i=1 +construct x +destruct x +g for i=2 +construct x +destruct x +g for i=3 +construct x +destruct x +g for i=4 +construct x +destruct x +g for i=5 +construct x +destruct x +g for i=6 +construct x +destruct x +g for i=7 +construct x +destruct x +g for i=8 +construct x +destruct x +g for i=9 +construct x +destruct x + +g while i=0 +construct x +destruct x +g while i=1 +construct x +destruct x +g while i=2 +construct x +destruct x +g while i=3 +construct x +destruct x +g while i=4 +construct x +destruct x +g while i=5 +construct x +destruct x +g while i=6 +construct x +destruct x +g while i=7 +construct x +destruct x +g while i=8 +construct x +destruct x +g while i=9 +construct x +destruct x + +construct y +g switch i=0 +destruct y +construct y +g switch i=1 +destruct y +construct y +g switch i=2 +destruct y +construct y +g switch i=3 +destruct y +construct y +g switch i=4 +destruct y +construct y +g switch i=5 +destruct y +construct y +g switch i=6 +destruct y +construct y +g switch i=7 +destruct y +construct y +g switch i=8 +destruct y +construct y +g switch i=9 +destruct y + +g for k=0 +g for i=0 +construct x +g for j=0 +construct y +continue L2 +destruct y +g for j=1 +construct y +break L2 +destruct y +destruct x +g for i=1 +construct x +g for j=0 +construct y +continue L2 +destruct y +g for j=1 +construct y +break L2 +destruct y +destruct x +g for i=2 +construct x +continue L1 +destruct x +g for i=3 +construct x +break L1 +destruct x +g for k=1 +g for i=0 +construct x +g for j=0 +construct y +continue L2 +destruct y +g for j=1 +construct y +break L2 +destruct y +destruct x +g for i=1 +construct x +g for j=0 +construct y +continue L2 +destruct y +g for j=1 +construct y +break L2 +destruct y +destruct x +g for i=2 +construct x +continue L1 +destruct x +g for i=3 +construct x +break L1 +destruct x + +construct w +construct v +break L3 +destruct v +destruct w + +h +construct y +L1 +construct x +L2 +goto L1 +destruct x +L1 +construct x +L2 +goto L2 +L2 +goto L3 +L3 +goto L2-2 +L2 +goto L4 +destruct x +destruct y +L4 +goto L0 +construct y +L1 +construct x +L2 +goto L4 +destruct x +destruct y +L4 Index: src/tests/raii/.expect/globals.txt =================================================================== --- src/tests/raii/.expect/globals.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/.expect/globals.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,9 @@ +static inline autogen value +no no no 22 +no no yes 22 +no yes no 22 +no yes yes 22 +yes no no 22 +yes no yes 22 +yes yes no 22 +yes yes yes 22 Index: src/tests/raii/.expect/memberCtors-ERR1.txt =================================================================== --- src/tests/raii/.expect/memberCtors-ERR1.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/.expect/memberCtors-ERR1.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,1 @@ +raii/memberCtors.c:71:1 error: in void ?{}(B &b), field a2 used before being constructed Index: src/tests/raii/.expect/memberCtors.txt =================================================================== --- src/tests/raii/.expect/memberCtors.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/.expect/memberCtors.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,213 @@ +Before declaration of b1 +constructing int +constructing int +constructing int +constructing int +constructing int +constructing int +begin construct B +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 +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +end copy construct A +begin ?=? A +copy constructing int: 1001 +destructing int: 1001 +destructing int: 1001 +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +end ?=? 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 +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 +assigning int: 0 0 +end construct A +end construct B +destructing int: 0 +destructing int: 0 +destructing int: 1001 +Before declaration of b2 +copy constructing int: 0 +copy constructing int: 0 +begin copy construct A +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 +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +end copy construct A +End of main +constructing int +constructing int +begin construct A +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 +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +end copy construct A +begin ?=? A +copy constructing int: 999 +destructing int: 999 +destructing int: 999 +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +end ?=? 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 +destructing int: 0 +end copy construct A +destructing int: 0 +destructing int: 0 +destructing int: 999 +destructing int: 0 +destructing int: 0 +destructing int: 999 +destructing int: 0 +destructing int: 0 +destructing int: 1000 +destructing int: 0 +destructing int: 0 +destructing int: 999 +destructing int: 0 +destructing int: 0 +destructing int: 0 +destructing int: 0 +destructing int: 0 +destructing int: 999 +constructing int +constructing int +begin construct A +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 +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +end copy construct A +begin ?=? A +copy constructing int: 999 +destructing int: 999 +destructing int: 999 +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +copy constructing int: 0 +destructing int: 0 +destructing int: 0 +end ?=? 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 +destructing int: 0 +end copy construct A +destructing int: 0 +destructing int: 0 +destructing int: 999 +destructing int: 0 +destructing int: 0 +destructing int: 999 +destructing int: 0 +destructing int: 0 +destructing int: 1000 +destructing int: 0 +destructing int: 0 +destructing int: 999 +destructing int: 0 +destructing int: 0 +destructing int: 0 +destructing int: 0 +destructing int: 0 +destructing int: 999 Index: src/tests/raii/ctor-autogen.c =================================================================== --- src/tests/raii/ctor-autogen.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/ctor-autogen.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,153 @@ +// TODO: add error cases (e.g., use of field constructors for managed types, etc.) + +enum Color { R, G, B }; + +// empty struct/union should have generated ctor/dtors +union U {}; +struct S {}; + +struct SimpleUnion { + int x; + double y; + char z; +}; + +struct SimpleStruct { + int x; + double y; + char z; +}; + +// struct/union with members with generated ctor/dtors should themselves have generated ctor/dtors +union PopulatedUnion { + Color c; + U u; + S s; +}; + +struct PopulatedStruct { + Color c; + U u; + S s; +}; + +// dtype-static generic type is otype +forall(dtype T) +struct DtypeStaticStruct { + T * data; + short size; +}; + +forall(dtype T) +union DtypeStaticUnion { + T * data; + short size; +}; + +// dynamic generic type is otype +forall(otype T) +struct DynamicStruct { + T x; +}; + +forall(otype T) +union DynamicUnion { + T x; +}; + +// struct/union that contains a generic type is +struct GenericContainingStruct { + DynamicStruct(int) dsi; + DynamicStruct(double) dsd; + DynamicUnion(int) dui; + DynamicUnion(double) dud; + DtypeStaticStruct(int) dssi; + DtypeStaticStruct(float) dssf; + DtypeStaticUnion(int) dsui; + DtypeStaticUnion(float) dsuf; +}; + +union GenericContainingUnion { + DynamicStruct(int) dsi; + DynamicStruct(double) dsd; + DynamicUnion(int) dui; + DynamicUnion(double) dud; + DtypeStaticStruct(int) dssi; + DtypeStaticStruct(float) dssf; + DtypeStaticUnion(int) dsui; + DtypeStaticUnion(float) dsuf; +}; + + +forall(otype T) +T identity(T x) { return x; } + +// can identity e if only sized or only the assertion, but the combination breaks... +// forall(dtype T | sized(T) | { void ?{}(T &); }) +// void identity(T x) { } + +#if ERR1 +// managed type - defines a constructor - can't use field constructors +struct Managed { + int x; +}; + +void ?{}(Managed & m) { m.x = 0; } + +// managed type since it contains a managed type - can't use field constructors +struct InheritManaged { + Managed m; +}; + +Managed x = { 123 }; // error +Managed y; // okay + +InheritManaged z = { y }; // error? +#endif + +int main() { + S s; + U u; + Color e; + + // identity(R); Color constant should be Color which is otype + identity(e); // Color should be an otype + identity(u); // U should be an otype + identity(s); // S should be an otype + + SimpleStruct ss; + SimpleUnion su; + + identity(ss); + identity(su); + + PopulatedStruct ps; + PopulatedUnion pu; + + identity(ps); // should recursively be an otype + identity(pu); // should recursively be an otype + + DynamicStruct(int) dsi; + DynamicStruct(double) dsd; + DynamicUnion(int) dui; + DynamicUnion(double) dud; + DtypeStaticStruct(int) dssi; + DtypeStaticStruct(float) dssf; + DtypeStaticUnion(int) dsui; + DtypeStaticUnion(float) dsuf; + + identity(dsi); + identity(dsd); + // identity(dui); // xxx - codegen errors in generated thunk _temp3 (Box-pass-generated assignment return-temporary) + // identity(dud); + identity(dssi); + identity(dssf); + identity(dsui); + identity(dsuf); + + GenericContainingStruct gcs; + GenericContainingUnion gcu; + + identity(gcs); + identity(gcu); +} Index: src/tests/raii/dtor-early-exit.c =================================================================== --- src/tests/raii/dtor-early-exit.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/dtor-early-exit.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,256 @@ +// +// 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. +// +// dtor-early-exit.c -- +// +// Author : Rob Schluntz +// Created On : Wed Aug 17 08:26:25 2016 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Aug 17 08:29:37 2016 +// Update Count : 2 +// + +#include +#include +extern "C" { +#define false ((int)0) // until stdbool.h works +#define assert(cond) if (! (cond)) { sout | "Assertion failed: (" | #cond | ") at " __FILE__ | ":" | __LINE__ | endl; abort(); } +} + +struct A { + const char * name; + int * x; +}; + +// 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 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 +void f(int i) { + sout | "f i=" | i | endl; + A x = { "x" }; // construct x + { + A y = { "y" }; // construct y + { + A z = { "z" }; // construct z + { + if (i == 0) return; // destruct x, y, z + } + if (i == 1) return; // destruct x, y, z + // destruct z + } + if (i == 2) return; // destruct x, y + // destruct y + } + return; // destruct x +} + +// test loops, switch, etc. +void g() { + for (int i = 0; i < 10; i++) { + sout | "g for i=" | i | endl; + A x = { "x" }; + // construct x + // destruct x + } + sout | endl; + { + int i = 0; + while (i < 10) { + sout | "g while i=" | i | endl; + A x = { "x" }; + // construct x + i++; + // destruct x + } + } + sout | endl; + for (int i = 0; i < 10; i++) { + switch(10) { + case 0: + case 5: + case 10: { + A y = { "y" }; + sout | "g switch i=" | i | endl; + // construct y + break; // destruct y + } + default: { + sout | "g switch i=" | i | endl; + A x = { "x" }; + // construct x + break; // destruct x + } + } + } + sout | endl; + for (int k = 0; k < 2; k++) { + sout | "g for k=" | k | endl; + L1: for (int i = 0; i < 10; i++) { + sout | "g for i=" | i | endl; + + A x = { "x" }; + if (i == 2) { + sout | "continue L1" | endl; + continue; // destruct x + } else if (i == 3) { + sout | "break L1" | endl; + break; // destruct x + } + + L2: for (int j = 0; j < 10; j++) { + sout | "g for j=" | j | endl; + A y = { "y" }; + if (j == 0) { + sout | "continue L2" | endl; + continue; // destruct y - missing because object that needs to be destructed is not a part of this block, it's a part of the for's block + } else if (j == 1) { + sout | "break L2" | endl; + break; // destruct y + } else if (i == 1) { + sout | "continue L1" | endl; + continue L1; // destruct x,y - note: continue takes you to destructors for block, so only generate destructor for y + } else if (k == 1) { + sout | "break L1" | endl; + break L1; // destruct x,y + } + } + } + } + + sout | endl; + L3: if( 3 ) { + A w = { "w" }; + if( 4 ) { + A v = { "v" }; + sout | "break L3" | endl; + break L3; + } + } +} + +// test goto +void h() { + int i = 0; + // for each goto G with target label L: + // * find all constructed variables alive at G (set S_G) + // * find all constructed variables alive at L (set S_L) + // * if S_L-S_G is non-empty, error + // * emit destructors for all variables in S_G-S_L + sout | "h" | endl; + { + L0: ; +#ifdef ERR1 + goto L1; // this is an error in g++ because it skips initialization of y +#endif + A y = { "y" }; + // S_L1 = { y } + L1: sout | "L1" | endl; + A x = { "x" }; + // S_L2 = { y, x } + L2: sout | "L2" | endl; + if (i == 0) { + ++i; + sout | "goto L1" | endl; + // S_G = { y, x } + goto L1; // jump back, destruct b/c before x definition + // S_L-S_G = {} => no error + // S_G-S_L = { x } => destruct x + } else if (i == 1) { + ++i; + sout | "goto L2" | endl; + // S_G = { y, x } + goto L2; // jump back, do not destruct + // S_L-S_G = {} + // S_G-S_L = {} => destruct nothing + } else if (i == 2) { + ++i; + sout | "goto L3" | endl; + // S_G = { y, x } + goto L3; // jump ahead, do not destruct + // S_L-S_G = {} + // S_G-S_L = {} + } else if (false) { + ++i; + A z = { "z" }; + sout | "goto L3-2" | endl; + // S_G = { z, y, x } + goto L3; + // S_L-S_G = {} + // S_G-S_L = {z} => destruct z + } else { + ++i; + sout | "goto L4" | endl; + // S_G = { y, x } + goto L4; // jump ahead, destruct b/c left block x was defined in + // S_L-S_G = {} + // S_G-S_L = { y, x } => destruct y, x + } + // S_L3 = { y, x } + L3: sout | "L3" | endl; + sout | "goto L2-2" | endl; + // S_G = { y, x } + goto L2; // jump back, do not destruct + // S_L-S_G = {} + // S_G-S_L = {} + } + // S_L4 = {} + L4: sout | "L4" | endl; + if (i == 4) { + sout | "goto L0" | endl; + // S_G = {} + goto L0; + // S_L-S_G = {} + // S_G-S_L = {} + } +#ifdef ERR2 + // S_G = {} + if (i == 5) goto L2; // this is an error in g++ because it skips initialization of y, x + // S_L-S_G = { y, x } => non-empty, so error +#endif +} + +// TODO: implement __label__ and uncomment these lines +void computedGoto() { + // __label__ bar; + void *ptr; + ptr = &&foo; + goto *ptr; + assert(false); +foo: ; +// void f() { +// ptr = &&bar; +// goto *ptr; +// assert(false); +// } +// f(); +// assert(false); +// bar: ; +} + +int main() { + sepDisable(sout); + for (int i = 0; i < 4; i++) { + f(i); + } + sout | endl; + g(); + sout | endl; + h(); + + computedGoto(); +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa dtor-early-exit" // +// End: // Index: src/tests/raii/globals.c =================================================================== --- src/tests/raii/globals.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/globals.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,83 @@ +#include + +struct value_t { + int value; +}; + +void ?{}( value_t & this ) { this.value = 22; } + +//Standard case +struct g_t { + value_t val; +}; + +void ?{}( g_t & this ) { (this.val){}; } + +g_t g; + +//Autogen case +struct ga_t { + value_t val; +}; + +ga_t ga; + +//Inline case +struct gi_t; +void ?{}( gi_t & this ); + +struct gi_t { + value_t val; +} gi; + +void ?{}( gi_t & this ) { (this.val){}; } + +//Inline autogen case +struct gia_t { + value_t val; +} gia; + +//Static case +struct gs_t { + value_t val; +}; + +void ?{}( gs_t & this ) { (this.val){}; } + +static gs_t gs; + +//Static autogen case +struct gsa_t { + value_t val; +}; + +static gsa_t gsa; + +//Static inline case +struct gsi_t; +void ?{}( gsi_t & this ); + +static struct gsi_t { + value_t val; +} gsi; + +void ?{}( gsi_t & this ) { (this.val){}; } + +//Static inline autogen case +static struct gsia_t { + value_t val; +} gsia; + +int main() { + sout | "static\t\tinline\t\tautogen\t\tvalue" | endl; + + sout | "no \t\tno \t\tno \t\t" | g.val.value | endl; + sout | "no \t\tno \t\tyes\t\t" | ga.val.value | endl; + sout | "no \t\tyes\t\tno \t\t" | gi.val.value | endl; + sout | "no \t\tyes\t\tyes\t\t" | gia.val.value | endl; + sout | "yes\t\tno \t\tno \t\t" | gs.val.value | endl; + sout | "yes\t\tno \t\tyes\t\t" | gsa.val.value | endl; + sout | "yes\t\tyes\t\tno \t\t" | gsi.val.value | endl; + sout | "yes\t\tyes\t\tyes\t\t" | gsia.val.value | endl; + +} Index: src/tests/raii/init_once.c =================================================================== --- src/tests/raii/init_once.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/init_once.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,195 @@ +// +// 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. +// +// init_once.c -- +// +// Author : Rob Schluntz +// Created On : Tue Jun 14 15:43:35 2016 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat Jul 9 11:30:29 2016 +// Update Count : 3 +// + +// want to ensure ctor/dtor called at most once per object. +// whole point of ctor/dtor is that you don't know what's in +// memory when it's first called, so can't rely on member to +// determine if this is true. instead, keep an array +// of addresses that have been constructed and remove the element +// when it's destructed (and vice-versa) + +//*** setup +extern "C" { +#define NULL 0 +void * malloc(size_t); +void free(void *); +#define assert(cond) if (! (cond)) { printf("Assertion failed: (%s) at %s:%d\n", #cond, __FILE__, __LINE__); abort(); } +void *memset(void *s, int c, size_t n); +} + +// dummy type +struct init_once { int * x; }; + +// array and operations +// const int size = 1024; +#define size 1024 +struct array { + init_once * elems[size]; + int length; +}; +void remove(array * arr, init_once * x) { + for (int i = 0; i < arr->length; i++) { + if ( arr->elems[i] == x ) { + arr->elems[i] = arr->elems[--arr->length]; + return; + } + } +} +void insert(array * arr, init_once * x) { + assert( arr->length < size ); + arr->elems[arr->length++] = x; +} +int find(array * arr, init_once * x) { + for (int i = 0; i < arr->length; i++) { + if ( arr->elems[i] == x ) { + return i; + } + } + return -1; +} +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 ); + + x.x = (int *)malloc(sizeof(int)); +} + +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 ); + + free(x.x); +} +//*** end setup + +// test globals +init_once x; +init_once y = x; + +void static_variable() { + static init_once x; +} + +int main() { + // local variables + init_once x; + init_once y = x; + + // block scoped variables + { + init_once x; + init_once y = x; + } + + // loop variables + for (int i = 0 ; i < 10; i++) { + init_once x; + init_once y = x; + } + int i = 0; + while (i < 10) { + init_once x; + init_once y = x; + i++; + } + + // declared in a switch block with a break + for (int i = 0; i < 10; i++) { + switch (10) { + case 1: { + init_once x; + init_once y = x; + x{}; // ensure this doesn't execute + break; + } + case 10: { + init_once x; + init_once y = x; + } // fall through + default: { + init_once x; + init_once y = x; + break; + } + } + } + + // labeled break/continue + L3: for (int k = 0; k < 10; k++) { + init_once x; + init_once y = x; + L1: for (int i = 0; i < 10; i++){ + init_once x; + init_once y = x; + L2: for (int j = 0; j < 10; j++) { + init_once x; + init_once y = x; + + if (i == 0) continue L1; + if (i == 1) continue L2; + if (i == 2) break L2; + if (i == 3) break L1; + if (i == 4) continue L3; + if (i == 9) break L3; + // if (i == 5) goto ; + } + } + } + + // labeled break/continue with if + LL1: for (int k = 0; k < 10; k++) { + init_once x; + init_once y = x; + LL2: for (int i = 0; i < 10; i++){ + init_once x; + init_once y = x; + LL3: if( i < 5) { + init_once x; + init_once y = x; + + if (i == 0) continue LL2; + if (i == 2) break LL3; + if (i == 3) break LL2; + if (i == 4) continue LL1; + } else { + if (i == 9) break LL1; + // if (i == 5) goto ; + } + } + } + + // function-scoped static variable + for (int i = 0; i < 10; i++) { + static_variable(); + } +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa init_once.c" // +// End: // Index: src/tests/raii/memberCtors.c =================================================================== --- src/tests/raii/memberCtors.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/memberCtors.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,91 @@ +struct WrappedInt { + int x; +}; + +void ?{}(WrappedInt & this) { + printf("constructing int\n"); + this.x = 0; +} + +void ?{}(WrappedInt & this, WrappedInt other) { + printf("copy constructing int: %d\n", other.x); + this.x = other.x; +} + +void ?{}(WrappedInt & this, int x) { + printf("constructing int: %d\n", x); + this.x = 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; +} + +struct A { + WrappedInt x, y, z; +}; + +void ?{}(A & a) { + // currently must define default ctor, since there's no "= default" syntax +} + +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("end construct A\n"); +} // z never constructed - will be automatically default constructed + +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("end copy construct A\n"); +} // z never constructed - will be automatically copy constructed + +A ?=?(A & this, A other) { + printf("begin ?=? A\n"); + this.x = other.x; + this.y = other.y; + this.z = other.z; + printf("end ?=? A\n"); + return this; +} + +struct B { + A a1, a2, a3; +}; + +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 }; +#ifdef ERR1 + (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){}; +} // a2, a3 never destructed - will be automatically destructed + +int main() { + printf("Before declaration of b1\n"); + B b1; + printf("Before declaration of b2\n"); + B b2 = b1; + printf("End of main\n"); +} Index: src/tests/raii/multiDimension.c =================================================================== --- src/tests/raii/multiDimension.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/multiDimension.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,75 @@ +struct X { + int a; + int * ptr; +}; + +void ?{}(X & this) { + printf("default constructing\n"); + (this.a){ 123 }; + this.ptr = (int *)malloc(sizeof(int)); +} + +void ?{}(X & this, X other) { + printf("copy constructing\n"); + (this.a){ other.a }; + this.ptr = (int *)malloc(sizeof(int)); +} + +void ?{}(X & this, int a) { + printf("constructing with %d\n", a); + (this.a){ a }; + this.ptr = (int *)malloc(sizeof(int)); +} + +void ^?{}(X & this) { + printf("destructing\n"); + free(this.ptr); +} + +X ?=?(X & this, X other) { + this.a = other.a; + return this; +} + +X global[10][10] = { + { 1, { 2 }, { 3 }, { 4 }, 5, 6, 7, 8, 9, 10, 11, 12 }, + { 1, 2, 3, 4 }, + { { 1234567 } } +}; + +X global2[3][3][3] = { + { + { 1, 2, 3 }, + { 4, 5, 6 }, + { 7, 8, 9 }, + { 10, 11, 12 } + }, + { + { 0, 0, 0 } + } +}; + +int foo() { + static X abc[3][3] = { + { 11, 22, 33, 44 }, + { 55, 66 }, + { 77 }, + { 88, 99, 1010 } + }; +} + +// ensure constructed const arrays continue to compile +const int global[1] = { -2 }; + +int main() { + X abc[4][4] = { + { 999, 1111 }, + { 1, 2, 3, 4, 5 }, + {}, + { 0 }, + { 88 } + }; + + foo(); + foo(); +} Index: src/tests/raii/multiDimension.txt =================================================================== --- src/tests/raii/multiDimension.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/raii/multiDimension.txt (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,304 @@ +constructing with 1 +constructing with 2 +constructing with 3 +constructing with 4 +constructing with 5 +constructing with 6 +constructing with 7 +constructing with 8 +constructing with 9 +constructing with 10 +constructing with 1 +constructing with 2 +constructing with 3 +constructing with 4 +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +constructing with 1234567 +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +constructing with 1 +constructing with 2 +constructing with 3 +constructing with 4 +constructing with 5 +constructing with 6 +constructing with 7 +constructing with 8 +constructing with 9 +constructing with 0 +constructing with 0 +constructing with 0 +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +default constructing +constructing with 999 +constructing with 1111 +default constructing +default constructing +constructing with 1 +constructing with 2 +constructing with 3 +constructing with 4 +default constructing +default constructing +default constructing +default constructing +constructing with 0 +default constructing +default constructing +default constructing +constructing with 11 +constructing with 22 +constructing with 33 +constructing with 55 +constructing with 66 +default constructing +constructing with 77 +default constructing +default constructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing +destructing Index: src/tests/sum.c =================================================================== --- src/tests/sum.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ src/tests/sum.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -11,9 +11,10 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Dec 7 09:13:36 2017 -// Update Count : 261 +// Last Modified On : Fri Jan 26 11:31:02 2018 +// Update Count : 271 // #include +#include void ?{}( int & c, zero_t ) { c = 0; } @@ -28,8 +29,8 @@ forall( otype T | sumable( T ) ) // use trait -T sum( unsigned int n, T a[] ) { - T total = 0; // instantiate T, select 0 - for ( unsigned int i = 0; i < n; i += 1 ) - total += a[i]; // select + +T sum( unsigned int size, T a[] ) { + T total = 0; // instantiate T from 0 by calling constructor + for ( unsigned int i = 0; i < size; i += 1 ) + total += a[i]; // select appropriate + return total; } // sum @@ -55,5 +56,5 @@ } // for sout | "sum from" | low | "to" | High | "is" - | sum( size, (unsigned char *)a ) | ", check" | (int)s | endl; + | sum( size, (unsigned char *)a ) | ", check" | (int)s | endl; int s = 0, a[size], v = low; @@ -63,5 +64,5 @@ } // for sout | "sum from" | low | "to" | High | "is" - | sum( size, (int *)a ) | ", check" | (int)s | endl; + | sum( size, (int *)a ) | ", check" | (int)s | endl; float s = 0.0f, a[size], v = low / 10.0f; @@ -71,5 +72,5 @@ } // for sout | "sum from" | low / 10.0f | "to" | High / 10.0f | "is" - | sum( size, (float *)a ) | ", check" | (float)s | endl; + | sum( size, (float *)a ) | ", check" | (float)s | endl; double s = 0.0, a[size], v = low / 10.0; @@ -79,5 +80,5 @@ } // for sout | "sum from" | low / 10.0 | "to" | High / 10.0 | "is" - | sum( size, (double *)a ) | ", check" | (double)s | endl; + | sum( size, (double *)a ) | ", check" | (double)s | endl; struct S { int i, j; }; @@ -98,5 +99,19 @@ } // for sout | "sum from" | low | "to" | High | "is" - | sum( size, (S *)a ) | ", check" | (S)s | endl; + | sum( size, (S *)a ) | ", check" | (S)s | endl; + + forall( otype Impl | sumable( Impl ) ) + struct GS { + Impl * x, * y; + }; + GS(int) gs; + gs.x = anew( size ); // create array storage for field + s = 0; v = low; + for ( int i = 0; i < size; i += 1, v += 1 ) { + s += (int)v; + gs.x[i] = (int)v; // set filed array in generic type + } // for + sout | "sum from" | low | "to" | High | "is" + | sum( size, gs.x ) | ", check" | (int)s | endl; // add filed array in generic type } // main Index: src/tests/vector.c =================================================================== --- src/tests/vector.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) +++ src/tests/vector.c (revision 7416d46ae4c80902ec659807c72c4b3d78cdba5c) @@ -0,0 +1,66 @@ +// +// 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. +// +// vector.c -- +// +// Author : Thierry Delisle +// Created On : Mon Jul 4 23:36:19 2016 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Jan 18 17:08:08 2018 +// Update Count : 27 +// + +#include +#include + +#undef assert +#define assert(x) \ + do { \ + if ( !(x) ) { \ + sout | "CHECK failed :" | #x | "at" | __FILE__ | " :" | __LINE__ | endl; \ + abort(); \ + } \ + } while( 0 == 1 ) + +int main() { + vector( int ) iv; + + assert( empty( &iv ) ); + assert( size( &iv ) == 0 ); + sout | size( &iv ) | endl; + + push_back( &iv, 1 ); + assert( size( &iv ) == 1 ); + sout | size( &iv ) | endl; + + push_back( &iv, 2 ); + assert( size( &iv ) == 2 ); + sout | size( &iv ) | endl; + + push_back( &iv, 3 ); + assert( size( &iv ) == 3 ); + sout | size( &iv ) | endl; + + assert( !empty( &iv ) ); + assert( size( &iv ) == 3 ); + assert( at( &iv, 0 ) == 1 ); + assert( (&iv)[0] == 1 ); + assert( at( &iv, 1 ) == 2 ); + assert( (&iv)[1] == 2 ); + assert( at( &iv, 2 ) == 3 ); + assert( (&iv)[2] == 3 ); + + clear( &iv ); + + assert( empty( &iv ) ); + assert( size( &iv ) == 0 ); + sout | size( &iv ) | endl; +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa vector.c" // +// End: // Index: src/tests/vector/array.c =================================================================== --- src/tests/vector/array.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,38 +1,0 @@ -// -// 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. -// -// array.c -- -// -// Author : Richard C. Bilson -// Created On : Wed May 27 17:56:53 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Wed Apr 27 17:21:52 2016 -// Update Count : 3 -// - -#include "array.h" - -forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) ) -[ elt_type * begin, elt_type * end ] get_iterators( array_type * array ) { - return [ begin( array ), end( array ) ]; -} - -// The first element is always at index 0. -forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) ) -elt_type * begin( array_type * array ) { - return &array[ 0 ]; -} - -// The end iterator should point one past the last element. -forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) ) -elt_type * end( array_type * array ) { - return &array[ last( array ) ] + 1; -} - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa array.c" // -// End: // Index: src/tests/vector/array.h =================================================================== --- src/tests/vector/array.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,49 +1,0 @@ -// -// 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. -// -// array.h -- -// -// Author : Richard C. Bilson -// Created On : Wed May 27 17:56:53 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 10:04:20 2017 -// Update Count : 6 -// - -#pragma once - -//#include - -// An array has contiguous elements accessible in any order using integer indicies. The first -// element has index 0. -trait array( otype array_type, otype elt_type ) { - elt_type & ?[?]( array_type, int ); -}; - -// A bounded array is an array that carries its maximum index with it. -trait bounded_array( otype array_type, otype elt_type | array( array_type *, elt_type ) ) { - int last( array_type * ); -}; - -// implement iterator_for - -forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) ) -[ elt_type * begin, elt_type * end ] get_iterators( array_type * ); - - -// A bounded array can be iterated over by using a pointer to the element type. These functions -// return iterators corresponding to the first element and the one-past-the-end element, STL-style. -forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) ) -elt_type * begin( array_type * array ); - -// The end iterator should point one past the last element. -forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) ) -elt_type * end( array_type * array ); - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa array.c" // -// End: // Index: src/tests/vector/vector_int.c =================================================================== --- src/tests/vector/vector_int.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,75 +1,0 @@ -// -// 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. -// -// vector_int.c -- -// -// Author : Richard C. Bilson -// Created On : Wed May 27 17:56:53 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jul 5 21:00:56 2016 -// Update Count : 4 -// - -#include "vector_int.h" -#include -#include - -#define DEFAULT_CAPACITY 20 - -void ?{}( vector_int & vec ) { - vec { DEFAULT_CAPACITY }; -} - -void ?{}( vector_int & vec, int reserve ) { - vec.last = -1; - vec.capacity = reserve; - vec.data = (int *)malloc( sizeof( int ) * reserve ); -} - -void ?{}( vector_int & vec, vector_int other ) { - vec.last = other.last; - vec.capacity = other.capacity; - vec.data = (int *)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 reserve( vector_int *vec, int reserve ) { - if ( reserve > vec->capacity ) { - vec->data = (int *)realloc( vec->data, sizeof( int ) * reserve ); - vec->capacity = reserve; - } -} - -void append( vector_int *vec, int element ) { - vec->last++; - if ( vec->last == vec->capacity ) { - vec->capacity *= 2; - vec->data = (int *)realloc( vec->data, sizeof( int ) * vec->capacity ); - } - vec->data[ vec->last ] = element; -} - -// implement bounded_array - -int & ?[?]( vector_int * vec, int index ) { - return vec->data[ index ]; -} - -int last( vector_int * vec ) { - return vec->last; -} - - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa vector_int.c" // -// End: // Index: src/tests/vector/vector_int.h =================================================================== --- src/tests/vector/vector_int.h (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,42 +1,0 @@ -// -// 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. -// -// vector_int.h -- -// -// Author : Richard C. Bilson -// Created On : Wed May 27 17:56:53 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 10:04:02 2017 -// Update Count : 4 -// - -#pragma once - -// A flexible array, similar to a C++ vector, that holds integers and can be resized dynamically - -typedef struct vector_int { - int last; // last used index - int capacity; // last possible index before reallocation - int *data; // array -} 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 reserve( vector_int *vec, int reserve ); // reserve more capacity -void append( vector_int *vec, int element ); // add element to end of vector, resizing as necessary - -// implement bounded_array - -int & ?[?]( vector_int * vec, int index ); // access to arbitrary element (does not resize) -int last( vector_int * vec ); // return last element - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa vector_int.c" // -// End: // Index: src/tests/vector/vector_test.c =================================================================== --- src/tests/vector/vector_test.c (revision f792cb8b86c581d70e5ef5363e56f8cec6130951) +++ (revision ) @@ -1,47 +1,0 @@ -// -// 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. -// -// vector_test.c -- -// -// Author : Richard C. Bilson -// Created On : Wed May 27 17:56:53 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 24 08:15:38 2017 -// Update Count : 19 -// - -#include -#include -#include "vector_int.h" -#include "array.h" - -int main( void ) { - vector_int vec; - - // read in numbers until EOF or error - int num; - - sout | "enter N elements and C-d on a separate line:" | endl; - for ( ;; ) { - sin | num; - if ( fail( sin ) || eof( sin ) ) break; - append( &vec, num ); - } - // write out the numbers - - sout | "Array elements:" | endl; - write( begin( &vec ), end( &vec ), sout ); - sout | endl; - - sout | "Array elements reversed:" | endl; - write_reverse( begin( &vec ), end( &vec ), sout ); - sout | endl; -} - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa vector_test.c vector_int.o array.o" // -// End: //