- Timestamp:
- Jan 30, 2018, 3:54:32 PM (8 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
- Children:
- 633a642
- Parents:
- f792cb8 (diff), 42be3c3 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Location:
- src
- Files:
-
- 7 added
- 12 deleted
- 68 edited
- 14 moved
Legend:
- Unmodified
- Added
- Removed
-
src/CodeGen/GenType.cc
rf792cb8 r7416d46a 26 26 27 27 namespace CodeGen { 28 class GenType : public Visitor { 29 public: 28 struct GenType : public WithVisitorRef<GenType>, public WithShortCircuiting { 30 29 GenType( const std::string &typeString, bool pretty = false, bool genC = false, bool lineMarks = false ); 31 30 std::string get_typeString() const { return typeString; } 32 31 void set_typeString( const std::string &newValue ) { typeString = newValue; } 33 32 34 virtual void visit( FunctionType *funcType ); 35 virtual void visit( VoidType *voidType ); 36 virtual void visit( BasicType *basicType ); 37 virtual void visit( PointerType *pointerType ); 38 virtual void visit( ArrayType *arrayType ); 39 virtual void visit( ReferenceType *refType ); 40 virtual void visit( StructInstType *structInst ); 41 virtual void visit( UnionInstType *unionInst ); 42 virtual void visit( EnumInstType *enumInst ); 43 virtual void visit( TypeInstType *typeInst ); 44 virtual void visit( TupleType * tupleType ); 45 virtual void visit( VarArgsType *varArgsType ); 46 virtual void visit( ZeroType *zeroType ); 47 virtual void visit( OneType *oneType ); 33 void previsit( BaseSyntaxNode * ); 34 void postvisit( BaseSyntaxNode * ); 35 36 void postvisit( FunctionType * funcType ); 37 void postvisit( VoidType * voidType ); 38 void postvisit( BasicType * basicType ); 39 void postvisit( PointerType * pointerType ); 40 void postvisit( ArrayType * arrayType ); 41 void postvisit( ReferenceType * refType ); 42 void postvisit( StructInstType * structInst ); 43 void postvisit( UnionInstType * unionInst ); 44 void postvisit( EnumInstType * enumInst ); 45 void postvisit( TypeInstType * typeInst ); 46 void postvisit( TupleType * tupleType ); 47 void postvisit( VarArgsType * varArgsType ); 48 void postvisit( ZeroType * zeroType ); 49 void postvisit( OneType * oneType ); 48 50 49 51 private: … … 59 61 60 62 std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) { 61 GenTypegt( baseString, pretty, genC, lineMarks );63 PassVisitor<GenType> gt( baseString, pretty, genC, lineMarks ); 62 64 std::ostringstream os; 63 65 … … 68 70 69 71 type->accept( gt ); 70 return os.str() + gt. get_typeString();72 return os.str() + gt.pass.get_typeString(); 71 73 } 72 74 … … 77 79 GenType::GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks ) : typeString( typeString ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {} 78 80 79 void GenType::visit( VoidType *voidType ) { 81 // *** BaseSyntaxNode 82 void GenType::previsit( BaseSyntaxNode * ) { 83 // turn off automatic recursion for all nodes, to allow each visitor to 84 // precisely control the order in which its children are visited. 85 visit_children = false; 86 } 87 88 void GenType::postvisit( BaseSyntaxNode * node ) { 89 std::stringstream ss; 90 node->print( ss ); 91 assertf( false, "Unhandled node reached in GenType: %s", ss.str().c_str() ); 92 } 93 94 void GenType::postvisit( VoidType * voidType ) { 80 95 typeString = "void " + typeString; 81 96 handleQualifiers( voidType ); 82 97 } 83 98 84 void GenType:: visit( BasicType *basicType ) {85 BasicType::Kind kind = basicType-> get_kind();99 void GenType::postvisit( BasicType * basicType ) { 100 BasicType::Kind kind = basicType->kind; 86 101 assert( 0 <= kind && kind < BasicType::NUMBER_OF_BASIC_TYPES ); 87 102 typeString = std::string( BasicType::typeNames[kind] ) + " " + typeString; … … 89 104 } 90 105 91 void GenType::genArray( const Type::Qualifiers & qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic ) {106 void GenType::genArray( const Type::Qualifiers & qualifiers, Type * base, Expression *dimension, bool isVarLen, bool isStatic ) { 92 107 std::ostringstream os; 93 108 if ( typeString != "" ) { … … 126 141 typeString = os.str(); 127 142 128 base->accept( * this);129 } 130 131 void GenType:: visit( PointerType *pointerType ) {132 assert( pointerType-> get_base()!= 0);133 if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType-> get_dimension()) {134 genArray( pointerType->get_qualifiers(), pointerType-> get_base(), pointerType->get_dimension(), pointerType->get_isVarLen(), pointerType->get_isStatic() );143 base->accept( *visitor ); 144 } 145 146 void GenType::postvisit( PointerType * pointerType ) { 147 assert( pointerType->base != 0); 148 if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->dimension ) { 149 genArray( pointerType->get_qualifiers(), pointerType->base, pointerType->dimension, pointerType->get_isVarLen(), pointerType->get_isStatic() ); 135 150 } else { 136 151 handleQualifiers( pointerType ); … … 140 155 typeString = "*" + typeString; 141 156 } // if 142 pointerType-> get_base()->accept( *this);143 } // if 144 } 145 146 void GenType:: visit( ArrayType *arrayType ) {147 genArray( arrayType->get_qualifiers(), arrayType-> get_base(), arrayType->get_dimension(), arrayType->get_isVarLen(), arrayType->get_isStatic() );148 } 149 150 void GenType:: visit( ReferenceType *refType ) {151 assert( refType-> get_base()!= 0);157 pointerType->base->accept( *visitor ); 158 } // if 159 } 160 161 void GenType::postvisit( ArrayType * arrayType ) { 162 genArray( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->get_isVarLen(), arrayType->get_isStatic() ); 163 } 164 165 void GenType::postvisit( ReferenceType * refType ) { 166 assert( refType->base != 0); 152 167 assertf( ! genC, "Reference types should not reach code generation." ); 153 168 handleQualifiers( refType ); 154 169 typeString = "&" + typeString; 155 refType-> get_base()->accept( *this);156 } 157 158 void GenType:: visit( FunctionType *funcType ) {170 refType->base->accept( *visitor ); 171 } 172 173 void GenType::postvisit( FunctionType * funcType ) { 159 174 std::ostringstream os; 160 175 … … 169 184 /************* parameters ***************/ 170 185 171 const std::list<DeclarationWithType *> &pars = funcType-> get_parameters();186 const std::list<DeclarationWithType *> &pars = funcType->parameters; 172 187 173 188 if ( pars.empty() ) { … … 191 206 typeString = os.str(); 192 207 193 if ( funcType-> get_returnVals().size() == 0 ) {208 if ( funcType->returnVals.size() == 0 ) { 194 209 typeString = "void " + typeString; 195 210 } else { 196 funcType-> get_returnVals().front()->get_type()->accept( *this);211 funcType->returnVals.front()->get_type()->accept( *visitor ); 197 212 } // if 198 213 199 214 // add forall 200 if( ! funcType-> get_forall().empty() && ! genC ) {215 if( ! funcType->forall.empty() && ! genC ) { 201 216 // assertf( ! genC, "Aggregate type parameters should not reach code generation." ); 202 217 std::ostringstream os; 203 218 PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks ); 204 219 os << "forall("; 205 cg.pass.genCommaList( funcType-> get_forall().begin(), funcType->get_forall().end() );220 cg.pass.genCommaList( funcType->forall.begin(), funcType->forall.end() ); 206 221 os << ")" << std::endl; 207 222 typeString = os.str() + typeString; … … 221 236 } 222 237 223 void GenType:: visit( StructInstType *structInst ) {224 typeString = structInst-> get_name()+ handleGeneric( structInst ) + " " + typeString;238 void GenType::postvisit( StructInstType * structInst ) { 239 typeString = structInst->name + handleGeneric( structInst ) + " " + typeString; 225 240 if ( genC ) typeString = "struct " + typeString; 226 241 handleQualifiers( structInst ); 227 242 } 228 243 229 void GenType:: visit( UnionInstType *unionInst ) {230 typeString = unionInst-> get_name()+ handleGeneric( unionInst ) + " " + typeString;244 void GenType::postvisit( UnionInstType * unionInst ) { 245 typeString = unionInst->name + handleGeneric( unionInst ) + " " + typeString; 231 246 if ( genC ) typeString = "union " + typeString; 232 247 handleQualifiers( unionInst ); 233 248 } 234 249 235 void GenType:: visit( EnumInstType *enumInst ) {236 typeString = enumInst-> get_name()+ " " + typeString;250 void GenType::postvisit( EnumInstType * enumInst ) { 251 typeString = enumInst->name + " " + typeString; 237 252 if ( genC ) typeString = "enum " + typeString; 238 253 handleQualifiers( enumInst ); 239 254 } 240 255 241 void GenType:: visit( TypeInstType *typeInst ) {242 typeString = typeInst-> get_name()+ " " + typeString;256 void GenType::postvisit( TypeInstType * typeInst ) { 257 typeString = typeInst->name + " " + typeString; 243 258 handleQualifiers( typeInst ); 244 259 } 245 260 246 void GenType:: visit( TupleType * tupleType ) {261 void GenType::postvisit( TupleType * tupleType ) { 247 262 assertf( ! genC, "Tuple types should not reach code generation." ); 248 263 unsigned int i = 0; … … 257 272 } 258 273 259 void GenType:: visit( VarArgsType *varArgsType ) {274 void GenType::postvisit( VarArgsType * varArgsType ) { 260 275 typeString = "__builtin_va_list " + typeString; 261 276 handleQualifiers( varArgsType ); 262 277 } 263 278 264 void GenType:: visit( ZeroType *zeroType ) {279 void GenType::postvisit( ZeroType * zeroType ) { 265 280 // ideally these wouldn't hit codegen at all, but should be safe to make them ints 266 281 typeString = (pretty ? "zero_t " : "long int ") + typeString; … … 268 283 } 269 284 270 void GenType:: visit( OneType *oneType ) {285 void GenType::postvisit( OneType * oneType ) { 271 286 // ideally these wouldn't hit codegen at all, but should be safe to make them ints 272 287 typeString = (pretty ? "one_t " : "long int ") + typeString; … … 274 289 } 275 290 276 void GenType::handleQualifiers( Type * type ) {291 void GenType::handleQualifiers( Type * type ) { 277 292 if ( type->get_const() ) { 278 293 typeString = "const " + typeString; -
src/CodeTools/DeclStats.cc
rf792cb8 r7416d46a 23 23 #include <utility> // for pair, make_pair 24 24 25 #include "Common/PassVisitor.h" 25 26 #include "Common/SemanticError.h" // for SemanticError 26 27 #include "Common/VectorMap.h" // for VectorMap … … 35 36 namespace CodeTools { 36 37 37 class DeclStats : public Visitor{38 struct DeclStats : public WithShortCircuiting { 38 39 template<typename T> 39 40 static void sum(T& a, const T& b) { a += b; } … … 61 62 62 63 struct ArgPackStats { 63 VectorMap<unsigned> n; ///< Count of decls with each number of elements 64 VectorMap<unsigned> n_basic; ///< Count of decls with each number of basic type elements 65 VectorMap<unsigned> n_poly; ///< Count of decls with each number of polymorphic elements 66 std::map<unsigned, unsigned> p_basic; ///< Count of decls with each percentage of basic type elements 67 std::map<unsigned, unsigned> p_poly; ///< Count of decls with each percentage of polymorphic elements 68 VectorMap<unsigned> n_types; ///< Count of decls with each number of distinct types in the pack 64 VectorMap<unsigned> n; ///< Count of decls with each number of elements 65 VectorMap<unsigned> n_basic; ///< Count of decls with each number of basic type elements 66 VectorMap<unsigned> n_generic; ///< Count of decls with each number of generic type elements 67 VectorMap<unsigned> n_poly; ///< Count of decls with each number of polymorphic elements 68 VectorMap<unsigned> n_compound; ///< Count of decls with each number of non-generic compound types 69 std::map<unsigned, unsigned> p_basic; ///< Count of decls with each percentage of basic type elements 70 std::map<unsigned, unsigned> p_generic; ///< Count of decls with each percentage of generic type elements 71 std::map<unsigned, unsigned> p_poly; ///< Count of decls with each percentage of polymorphic elements 72 std::map<unsigned, unsigned> p_compound; ///< Count of decls with each percentage of non-generic compound type elements 73 VectorMap<unsigned> n_types; ///< Count of decls with each number of distinct types in the pack 69 74 /// Count of decls with each percentage of new types in lists. 70 75 /// Types used in the parameter list that recur in the return list are not considered to be new. … … 74 79 sum(n, o.n); 75 80 sum(n_basic, o.n_basic); 81 sum(n_generic, o.n_generic); 76 82 sum(n_poly, o.n_poly); 83 sum(n_compound, o.n_compound); 77 84 sum(p_basic, o.p_basic); 85 sum(p_generic, o.p_generic); 78 86 sum(p_poly, o.p_poly); 87 sum(p_compound, o.p_compound); 79 88 sum(n_types, o.n_types); 80 89 sum(p_new, o.p_new); … … 88 97 /// Count of declarations with each number of assertion parameters 89 98 VectorMap<unsigned> n_type_params; 99 /// Count of generic types with each number of type parameters 100 VectorMap<unsigned> n_generic_params; 101 /// Count of maximum nesting depth of types 102 VectorMap<unsigned> n_generic_nesting; 90 103 /// Count of declarations with each name 91 104 std::unordered_map<std::string, unsigned> by_name; 92 105 /// Count of uses of each basic type 93 106 std::unordered_map<std::string, unsigned> basic_type_names; 94 /// Count of uses of each non-basic type 107 /// Count of uses of each generic type name (includes "*", "[]", "(*)", "[,]") 108 std::unordered_map<std::string, unsigned> generic_type_names; 109 /// Count of uses of each non-generic aggregate type 95 110 std::unordered_map<std::string, unsigned> compound_type_names; 96 111 /// Count of decls using each basic type 97 112 std::unordered_map<std::string, unsigned> basic_type_decls; 113 /// Count of decls using each generic type (includes "*", "[]", "(*)", "[,]") 114 std::unordered_map<std::string, unsigned> generic_type_decls; 98 115 /// Count of decls using each compound type 99 116 std::unordered_map<std::string, unsigned> compound_type_decls; … … 110 127 ArgPackStats assn_returns; 111 128 112 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() {} 129 Stats() : n_decls(0), n_type_params(), n_generic_params(), n_generic_nesting(), 130 by_name(), basic_type_names(), generic_type_names(), compound_type_names(), 131 basic_type_decls(), generic_type_decls(), compound_type_decls(), params(), 132 returns(), n_assns(), assn_params(), assn_returns() {} 113 133 114 134 public: … … 116 136 sum( n_decls, o.n_decls ); 117 137 sum( n_type_params, o.n_type_params ); 138 sum( n_generic_params, o.n_generic_params ); 139 sum( n_generic_nesting, o.n_generic_nesting ); 118 140 sum( by_name, o.by_name ); 119 141 sum( basic_type_names, o.basic_type_names ); 142 sum( generic_type_names, o.generic_type_names ); 120 143 sum( compound_type_names, o.compound_type_names ); 121 144 sum( basic_type_decls, o.basic_type_decls ); 145 sum( generic_type_decls, o.generic_type_decls ); 122 146 sum( compound_type_decls, o.compound_type_decls ); 123 147 sum( params, o.params ); … … 131 155 }; 132 156 133 Stats for_linkage[LinkageSpec::NoOfSpecs]; ///< Stores separate stats per linkage 157 /// number of counting bins for linkages 158 static const unsigned n_named_specs = 8; 159 /// map from total number of specs to bins 160 static const unsigned ind_for_linkage[16]; 161 162 Stats for_linkage[n_named_specs]; ///< Stores separate stats per linkage 134 163 std::unordered_set<std::string> seen_names; ///< Stores manglenames already seen to avoid double-counting 135 164 Stats total; … … 137 166 std::map<std::pair<unsigned, unsigned>, unsigned> exprs_by_fanout_at_depth; 138 167 168 void countType( const std::string& name, unsigned& n, std::unordered_map<std::string, 169 unsigned>& names, std::unordered_map<std::string, unsigned>& decls, 170 std::unordered_set<std::string>& elSeen ) { 171 ++n; 172 ++names[ name ]; 173 if ( elSeen.insert( name ).second ) { ++decls[ name ]; } 174 } 175 176 void update_max( unsigned& max, unsigned crnt ) { 177 if ( crnt > max ) max = crnt; 178 } 179 180 void analyzeSubtype( Type* ty, Stats& stats, std::unordered_set<std::string>& elSeen, 181 unsigned& n_poly, bool& seen_poly, unsigned& max_depth, unsigned depth ) { 182 unsigned x; 183 analyzeType( ty, stats, elSeen, x, x, n_poly, x, seen_poly, max_depth, depth + 1 ); 184 } 185 186 void analyzeSubtypes( std::list<DeclarationWithType*>& tys, Stats& stats, 187 std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly, 188 unsigned& max_depth, unsigned depth, unsigned& n_subs ) { 189 for ( DeclarationWithType* dwt : tys ) { 190 Type* ty = dwt->get_type(); 191 n_subs += (unsigned)( dynamic_cast<VoidType*>(ty) != nullptr ); 192 analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth ); 193 } 194 } 195 196 void analyzeSubtypes( std::list<Expression*>& tys, Stats& stats, 197 std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly, 198 unsigned& max_depth, unsigned depth ) { 199 for ( Expression* expr : tys ) { 200 TypeExpr* texpr = dynamic_cast<TypeExpr*>(expr); 201 if ( ! texpr ) continue; 202 Type* ty = texpr->get_type(); 203 analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth ); 204 } 205 } 206 207 void analyzeSubtypes( std::list<Type*>& tys, Stats& stats, 208 std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly, 209 unsigned& max_depth, unsigned depth ) { 210 for ( Type* ty : tys ) { 211 analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth ); 212 } 213 } 214 215 void analyzeType( Type* ty, Stats& stats, std::unordered_set<std::string>& elSeen, 216 unsigned& n_basic, unsigned& n_generic, unsigned& n_poly, unsigned& n_agg, 217 bool& seen_poly, unsigned& max_depth, unsigned depth = 0 ) { 218 if ( BasicType* bt = dynamic_cast<BasicType*>(ty) ) { 219 std::string name = BasicType::typeNames[ bt->get_kind() ]; 220 countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen ); 221 update_max( max_depth, depth ); 222 } else if ( PointerType* pt = dynamic_cast<PointerType*>(ty) ) { 223 std::string name = "*"; 224 countType( 225 name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen); 226 analyzeSubtype( 227 pt->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth ); 228 ++stats.n_generic_params.at( 1 ); 229 } else if ( ArrayType* at = dynamic_cast<ArrayType*>(ty) ) { 230 std::string name = "[]"; 231 countType( 232 name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen); 233 analyzeSubtype( 234 at->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth ); 235 ++stats.n_generic_params.at( 1 ); 236 } else if ( ReferenceType* rt = dynamic_cast<ReferenceType*>(ty) ) { 237 std::string name = "&"; 238 countType( 239 name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen); 240 analyzeSubtype( 241 rt->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth ); 242 ++stats.n_generic_params.at( 1 ); 243 } else if ( FunctionType* ft = dynamic_cast<FunctionType*>(ty) ) { 244 std::string name = "(*)"; 245 countType( 246 name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen); 247 unsigned n_subs = 0; 248 analyzeSubtypes( 249 ft->get_returnVals(), stats, elSeen, n_poly, seen_poly, max_depth, depth, 250 n_subs ); 251 analyzeSubtypes( 252 ft->get_parameters(), stats, elSeen, n_poly, seen_poly, max_depth, depth, 253 n_subs ); 254 ++stats.n_generic_params.at( n_subs ); 255 } else if ( TypeInstType* vt = dynamic_cast<TypeInstType*>(ty) ) { 256 if ( ! seen_poly ) { 257 ++n_poly; 258 seen_poly = true; 259 } 260 countType( 261 vt->get_name(), n_agg, stats.compound_type_names, stats.compound_type_decls, 262 elSeen ); 263 update_max( max_depth, depth ); 264 } else if ( ReferenceToType* st = dynamic_cast<ReferenceToType*>(ty) ) { 265 std::list<Expression*>& params = st->get_parameters(); 266 if ( params.empty() ) { 267 countType( 268 st->get_name(), n_agg, stats.compound_type_names, 269 stats.compound_type_decls, elSeen ); 270 update_max( max_depth, depth ); 271 } else { 272 countType( 273 st->get_name(), n_generic, stats.generic_type_names, 274 stats.generic_type_decls, elSeen); 275 analyzeSubtypes( params, stats, elSeen, n_poly, seen_poly, max_depth, depth ); 276 ++stats.n_generic_params.at( params.size() ); 277 } 278 } else if ( TupleType* tt = dynamic_cast<TupleType*>(ty) ) { 279 std::string name = "[,]"; 280 countType( 281 name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen); 282 analyzeSubtypes( 283 tt->get_types(), stats, elSeen, n_poly, seen_poly, max_depth, depth ); 284 ++stats.n_generic_params.at( tt->size() ); 285 } else if ( dynamic_cast<VarArgsType*>(ty) ) { 286 std::string name = "..."; 287 countType( 288 name, n_agg, stats.compound_type_names, stats.compound_type_decls, elSeen ); 289 update_max( max_depth, depth ); 290 } else if ( dynamic_cast<ZeroType*>(ty) ) { 291 std::string name = "0"; 292 countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen ); 293 update_max( max_depth, depth ); 294 } else if ( dynamic_cast<OneType*>(ty) ) { 295 std::string name = "1"; 296 countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen ); 297 update_max( max_depth, depth ); 298 } 299 } 300 139 301 /// Update arg pack stats based on a declaration list 140 void analyze( Stats& stats, std::unordered_set<std::string>& seen, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) { 302 void analyze( Stats& stats, std::unordered_set<std::string>& seen, 303 std::unordered_set<std::string>& elSeen, ArgPackStats& pstats, 304 std::list<DeclarationWithType*>& decls ) { 141 305 std::unordered_set<std::string> types; 142 unsigned n = 0; ///< number of args/returns 143 unsigned n_basic = 0; ///< number of basic types 144 unsigned n_poly = 0; ///< number of polymorphic types 145 unsigned n_new = 0; ///< number of new types 306 unsigned n = 0; ///< number of args/returns 307 unsigned n_basic = 0; ///< number of basic types 308 unsigned n_generic = 0; ///< number of generic types (includes "*", "&", "[]", "(*)", "[,]") 309 unsigned n_poly = 0; ///< number of polymorphic types 310 unsigned n_agg = 0; ///< number of non-generic aggregate types 311 unsigned n_new = 0; ///< number of new types 312 146 313 for ( auto decl : decls ) { 147 314 Type* dt = decl->get_type(); … … 152 319 dt->print( ss ); 153 320 types.insert( ss.str() ); 154 bool this_new = seen.insert( ss.str() ).second; 155 if ( this_new ) { ++n_new; } 156 157 if ( dynamic_cast<BasicType*>( dt ) ) { 158 ++n_basic; 159 ++stats.basic_type_names[ ss.str() ]; 160 if ( this_new ) { 161 ++stats.basic_type_decls[ ss.str() ]; 162 } 163 } else if ( GenPoly::hasPolyBase( dt ) ) { 164 ++n_poly; 165 } else { 166 ++stats.compound_type_names[ ss.str() ]; 167 if ( this_new ) { 168 ++stats.compound_type_decls[ ss.str() ]; 169 } 170 } 171 } 321 if ( seen.insert( ss.str() ).second ) { ++n_new; } 322 323 bool seen_poly = false; 324 unsigned max_depth = 0; 325 analyzeType( 326 dt, stats, elSeen, n_basic, n_generic, n_poly, n_agg, seen_poly, max_depth ); 327 ++stats.n_generic_nesting.at( max_depth ); 328 } 329 172 330 ++pstats.n.at( n ); 173 331 ++pstats.n_basic.at( n_basic ); 332 ++pstats.n_generic.at( n_generic ); 174 333 ++pstats.n_poly.at( n_poly ); 334 ++pstats.n_compound.at( n_agg ); 175 335 if ( n > 0 ) { 176 336 ++pstats.p_basic[ n_basic*100/n ]; 337 ++pstats.p_generic[ n_generic*100/n ]; 177 338 ++pstats.p_poly[ n_poly*100/n ]; 178 ++pstats.p_new[ n_new*100/n ]; 339 ++pstats.p_compound[ n_agg*100/n ]; 340 if ( n > 1 ) ++pstats.p_new[ (n_new-1)*100/(n-1) ]; 179 341 } 180 342 ++pstats.n_types.at( types.size() ); … … 183 345 void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) { 184 346 std::unordered_set<std::string> seen; 185 analyze( stats, seen, params, fnTy->get_parameters() ); 186 analyze( stats, seen, returns, fnTy->get_returnVals() ); 347 std::unordered_set<std::string> elSeen; 348 analyze( stats, seen, elSeen, params, fnTy->get_parameters() ); 349 analyze( stats, seen, elSeen, returns, fnTy->get_returnVals() ); 187 350 } 188 351 … … 200 363 201 364 public: 202 using Visitor::visit; 203 204 virtual void visit( FunctionDecl *decl ) { 365 void previsit( FunctionDecl *decl ) { 205 366 // skip if already seen declaration for this function 206 const std::string& mangleName = decl->get_mangleName().empty() ? decl->get_name() : decl->get_mangleName(); 207 if ( ! seen_names.insert( mangleName ).second ) { 208 maybeAccept( decl->get_statements(), *this ); 209 return; 210 } 211 212 Stats& stats = for_linkage[ decl->get_linkage() ]; 213 214 ++stats.n_decls; 215 FunctionType* fnTy = decl->get_functionType(); 216 const Type::ForallList& forall = fnTy->get_forall(); 217 ++stats.n_type_params.at( forall.size() ); 218 unsigned n_assns = 0; 219 for ( TypeDecl* fdecl : forall ) { 220 n_assns += fdecl->get_assertions().size(); 221 for ( DeclarationWithType* assn : fdecl->get_assertions() ) { 222 FunctionType *assnTy = 0; 223 if ( ObjectDecl *assnObj = dynamic_cast<ObjectDecl*>(assn) ) { 224 if ( PointerType *ptrTy = dynamic_cast<PointerType*>(assnObj->get_type()) ) { 225 assnTy = dynamic_cast<FunctionType*>(ptrTy->get_base()); 226 } else assnTy = dynamic_cast<FunctionType*>(assnObj->get_type()); 227 } else if ( FunctionDecl *assnDecl = dynamic_cast<FunctionDecl*>(assn) ) { 228 assnTy = assnDecl->get_functionType(); 367 const std::string& mangleName = decl->get_mangleName().empty() ? decl->name : decl->get_mangleName(); 368 if ( seen_names.insert( mangleName ).second ) { 369 Stats& stats = for_linkage[ ind_for_linkage[ decl->linkage ] ]; 370 371 ++stats.n_decls; 372 FunctionType* fnTy = decl->type; 373 const Type::ForallList& forall = fnTy->forall; 374 ++stats.n_type_params.at( forall.size() ); 375 unsigned n_assns = 0; 376 for ( TypeDecl* fdecl : forall ) { 377 n_assns += fdecl->assertions.size(); 378 for ( DeclarationWithType* assn : fdecl->assertions ) { 379 FunctionType *assnTy = nullptr; 380 if ( ObjectDecl *assnObj = dynamic_cast<ObjectDecl*>(assn) ) { 381 if ( PointerType *ptrTy = dynamic_cast<PointerType*>(assnObj->get_type()) ) { 382 assnTy = dynamic_cast<FunctionType*>(ptrTy->base); 383 } else assnTy = dynamic_cast<FunctionType*>(assnObj->get_type()); 384 } else if ( FunctionDecl *assnDecl = dynamic_cast<FunctionDecl*>(assn) ) { 385 assnTy = assnDecl->type; 386 } 387 if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns ); 229 388 } 230 if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns ); 231 } 232 } 233 ++stats.n_assns[ n_assns ]; 234 235 ++stats.by_name[ decl->get_name() ]; 236 237 analyzeFunc( fnTy, stats, stats.params, stats.returns ); 238 239 // analyze expressions in decl statements 240 maybeAccept( decl->get_statements(), *this ); 241 } 242 243 virtual void visit( UntypedExpr *expr ) { 389 } 390 ++stats.n_assns[ n_assns ]; 391 ++stats.by_name[ decl->name ]; 392 analyzeFunc( fnTy, stats, stats.params, stats.returns ); 393 } 394 } 395 396 void previsit( UntypedExpr *expr ) { 397 visit_children = false; 244 398 analyzeExpr( expr, 0 ); 245 399 } … … 272 426 template<typename F> 273 427 void printAllHisto( const std::string& name, F extract ) { 274 VectorMap<unsigned> histos[ LinkageSpec::NoOfSpecs];428 VectorMap<unsigned> histos[n_named_specs]; 275 429 VectorMap<unsigned> thisto; 276 430 277 431 for ( const auto& entry : extract(total) ) { ++thisto.at( entry.second ); } 278 432 279 for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) {433 for ( unsigned i = 0; i < n_named_specs; ++i ) { 280 434 // can't be a higher count in one of the sub-histograms than the total 281 435 histos[i].reserve( thisto.size() ); … … 295 449 template<typename F> 296 450 void printAllSparseHisto( const std::string& name, F extract ) { 297 std::map<unsigned, unsigned> histos[ LinkageSpec::NoOfSpecs];451 std::map<unsigned, unsigned> histos[n_named_specs]; 298 452 std::map<unsigned, unsigned> thisto; 299 453 300 454 for ( const auto& entry : extract(total) ) { ++thisto[ entry.second ]; } 301 455 302 for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) {456 for ( unsigned i = 0; i < n_named_specs; ++i ) { 303 457 for ( const auto& entry : extract(for_linkage[i]) ) { ++histos[i][entry.second]; } 304 458 } … … 307 461 const auto& key = entry.first; 308 462 std::cout << "\"" << name << "\"," << key; 309 for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) {463 for ( unsigned i = 0; i < n_named_specs; ++i ) { 310 464 auto it = histos[i].find( key ); 311 465 if ( it == histos[i].end() ) std::cout << ",0"; … … 319 473 void printAllPack( const std::string& name, F extract ) { 320 474 printAllMap("n_basic_" + name, [&extract](const Stats& stats) { return extract(stats).n_basic; }); 475 printAllMap("n_generic_" + name, [&extract](const Stats& stats) { return extract(stats).n_generic; }); 321 476 printAllMap("n_poly_" + name, [&extract](const Stats& stats) { return extract(stats).n_poly; }); 477 printAllMap("n_compound_" + name, [&extract](const Stats& stats) { return extract(stats).n_compound; }); 322 478 printAllMap("n_" + name, [&extract](const Stats& stats) { return extract(stats).n; }); 323 479 printAllMap("%_basic_" + name, [&extract](const Stats& stats) { return extract(stats).p_basic; }); 480 printAllMap("%_generic_" + name, [&extract](const Stats& stats) { return extract(stats).p_generic; }); 324 481 printAllMap("%_poly_" + name, [&extract](const Stats& stats) { return extract(stats).p_poly; }); 482 printAllMap("%_compound_" + name, [&extract](const Stats& stats) { return extract(stats).p_compound; }); 325 483 printAllMap("n_distinct_types_" + name, [&extract](const Stats& stats) { return extract(stats).n_types; }); 326 484 printAllMap("%_new_types_in_" + name, [&extract](const Stats& stats) { return extract(stats).p_new; }); … … 342 500 } 343 501 344 std::cout << ",,\"intrinsic\",\"Cforall\",\"C\",\"autogen\",\" builtin\",\"TOTAL\"" << std::endl;502 std::cout << ",,\"intrinsic\",\"Cforall\",\"C\",\"autogen\",\"compiler\",\"builtinCFA\",\"builtinC\",\"other\",\"TOTAL\"" << std::endl; 345 503 346 504 printAllMap("n_type_params", [](const Stats& stats) { return stats.n_type_params; }); 505 printAllMap("n_generic_params", [](const Stats& stats) { return stats.n_generic_params; }); 506 printAllMap("n_generic_nesting", [](const Stats& stats) { return stats.n_generic_nesting; }); 347 507 printAll("n_decls", [](const Stats& stats) { return stats.n_decls; }); 348 508 printAll("unique_names", [](const Stats& stats) { return stats.by_name.size(); }); … … 351 511 printAllSparseHisto("basic_type_uses", [](const Stats& stats) { return stats.basic_type_names; }); 352 512 printAllSparseHisto("decls_using_basic_type", [](const Stats& stats) { return stats.basic_type_decls; }); 513 printAll("generic_type_names", [](const Stats& stats) { return stats.generic_type_names.size(); }); 514 printAllSparseHisto("generic_type_uses", [](const Stats& stats) { return stats.generic_type_names; }); 515 printAllSparseHisto("decls_using_generic_type", [](const Stats& stats) { return stats.generic_type_decls; }); 353 516 printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); }); 354 517 printAllSparseHisto("compound_type_uses", [](const Stats& stats) { return stats.compound_type_names; }); … … 365 528 }; 366 529 530 const unsigned DeclStats::ind_for_linkage[] 531 = { 7, 7, 2, 1, 7, 7, 7, 3, 4, 7, 6, 5, 7, 7, 7, 0 }; 532 367 533 void printDeclStats( std::list< Declaration * > &translationUnit ) { 368 DeclStatsstats;534 PassVisitor<DeclStats> stats; 369 535 acceptAll( translationUnit, stats ); 370 stats.p rint();536 stats.pass.print(); 371 537 } 372 538 -
src/Common/PassVisitor.h
rf792cb8 r7416d46a 19 19 #include "SynTree/Expression.h" 20 20 #include "SynTree/Constant.h" 21 #include "SynTree/TypeSubstitution.h" 21 22 class TypeSubstitution; 22 23 23 24 #include "PassVisitor.proto.h" … … 118 119 virtual void visit( StmtExpr * stmtExpr ) override final; 119 120 virtual void visit( UniqueExpr * uniqueExpr ) override final; 121 virtual void visit( UntypedInitExpr * initExpr ) override final; 122 virtual void visit( InitExpr * initExpr ) override final; 120 123 121 124 virtual void visit( VoidType * basicType ) override final; … … 210 213 virtual Expression * mutate( StmtExpr * stmtExpr ) override final; 211 214 virtual Expression * mutate( UniqueExpr * uniqueExpr ) override final; 215 virtual Expression * mutate( UntypedInitExpr * initExpr ) override final; 216 virtual Expression * mutate( InitExpr * initExpr ) override final; 212 217 213 218 virtual Type * mutate( VoidType * basicType ) override final; … … 403 408 }; 404 409 410 #include "SynTree/TypeSubstitution.h" 405 411 #include "PassVisitor.impl.h" -
src/Common/PassVisitor.impl.h
rf792cb8 r7416d46a 62 62 63 63 template< typename pass_type > 64 staticinline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {64 inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) { 65 65 DeclList_t* beforeDecls = visitor.get_beforeDecls(); 66 66 DeclList_t* afterDecls = visitor.get_afterDecls(); … … 90 90 91 91 template< typename pass_type > 92 staticinline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {92 inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) { 93 93 DeclList_t* beforeDecls = mutator.get_beforeDecls(); 94 94 DeclList_t* afterDecls = mutator.get_afterDecls(); … … 1853 1853 } 1854 1854 1855 //-------------------------------------------------------------------------- 1856 // UntypedInitExpr 1857 template< typename pass_type > 1858 void PassVisitor< pass_type >::visit( UntypedInitExpr * node ) { 1859 VISIT_START( node ); 1860 1861 indexerScopedAccept( node->result, *this ); 1862 maybeAccept_impl ( node->expr , *this ); 1863 // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver. 1864 1865 VISIT_END( node ); 1866 } 1867 1868 template< typename pass_type > 1869 Expression * PassVisitor< pass_type >::mutate( UntypedInitExpr * node ) { 1870 MUTATE_START( node ); 1871 1872 indexerScopedMutate( node->env , *this ); 1873 indexerScopedMutate( node->result, *this ); 1874 maybeMutate_impl ( node->expr , *this ); 1875 // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver. 1876 1877 MUTATE_END( Expression, node ); 1878 } 1879 1880 //-------------------------------------------------------------------------- 1881 // InitExpr 1882 template< typename pass_type > 1883 void PassVisitor< pass_type >::visit( InitExpr * node ) { 1884 VISIT_START( node ); 1885 1886 indexerScopedAccept( node->result, *this ); 1887 maybeAccept_impl ( node->expr , *this ); 1888 maybeAccept_impl ( node->designation, *this ); 1889 1890 VISIT_END( node ); 1891 } 1892 1893 template< typename pass_type > 1894 Expression * PassVisitor< pass_type >::mutate( InitExpr * node ) { 1895 MUTATE_START( node ); 1896 1897 indexerScopedMutate( node->env , *this ); 1898 indexerScopedMutate( node->result, *this ); 1899 maybeMutate_impl ( node->expr , *this ); 1900 maybeMutate_impl ( node->designation, *this ); 1901 1902 MUTATE_END( Expression, node ); 1903 } 1904 1855 1905 template< typename pass_type > 1856 1906 void PassVisitor< pass_type >::visit( VoidType * node ) { -
src/Concurrency/Waitfor.cc
rf792cb8 r7416d46a 507 507 new ListInit({ 508 508 new SingleInit( new AddressExpr( new VariableExpr( index ) ) ), 509 new SingleInit( new VariableExpr( acceptables ) ), 510 new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) ) 509 new ListInit({ 510 new SingleInit( new VariableExpr( acceptables ) ), 511 new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) ) 512 }) 511 513 }) 512 514 ); -
src/ControlStruct/ExceptTranslate.cc
rf792cb8 r7416d46a 316 316 VarExprReplacer::DeclMap mapping; 317 317 mapping[ handler_decl ] = local_except; 318 VarExprReplacer mapper( mapping ); 319 handler->get_body()->accept( mapper ); 318 VarExprReplacer::replace( handler->body, mapping ); 320 319 } 321 320 -
src/ControlStruct/LabelFixer.cc
rf792cb8 r7416d46a 44 44 45 45 void LabelFixer::postvisit( FunctionDecl * functionDecl ) { 46 MLEMutatormlemut( resolveJumps(), generator );46 PassVisitor<MLEMutator> mlemut( resolveJumps(), generator ); 47 47 functionDecl->acceptMutator( mlemut ); 48 48 } -
src/ControlStruct/MLEMutator.cc
rf792cb8 r7416d46a 46 46 void MLEMutator::fixBlock( std::list< Statement * > &kids ) { 47 47 for ( std::list< Statement * >::iterator k = kids.begin(); k != kids.end(); k++ ) { 48 *k = (*k)->acceptMutator(* this);48 *k = (*k)->acceptMutator(*visitor); 49 49 50 50 if ( ! get_breakLabel().empty() ) { … … 57 57 } 58 58 59 CompoundStmt* MLEMutator::mutate( CompoundStmt *cmpndStmt ) { 60 bool labeledBlock = !(cmpndStmt->get_labels().empty()); 59 void MLEMutator::premutate( CompoundStmt *cmpndStmt ) { 60 visit_children = false; 61 bool labeledBlock = !(cmpndStmt->labels.empty()); 61 62 if ( labeledBlock ) { 62 63 Label brkLabel = generator->newLabel("blockBreak", cmpndStmt); … … 65 66 66 67 // a child statement may set the break label - if they do, attach it to the next statement 67 std::list< Statement * > &kids = cmpndStmt-> get_kids();68 std::list< Statement * > &kids = cmpndStmt->kids; 68 69 fixBlock( kids ); 69 70 … … 75 76 enclosingControlStructures.pop_back(); 76 77 } // if 77 78 return cmpndStmt; 79 } 80 81 template< typename LoopClass > 82 Statement *MLEMutator::handleLoopStmt( LoopClass *loopStmt ) { 83 // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine 84 // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested 85 // loops 86 Label brkLabel = generator->newLabel("loopBreak", loopStmt); 87 Label contLabel = generator->newLabel("loopContinue", loopStmt); 88 enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) ); 89 loopStmt->set_body ( loopStmt->get_body()->acceptMutator( *this ) ); 90 91 assert( ! enclosingControlStructures.empty() ); 92 Entry &e = enclosingControlStructures.back(); 93 // sanity check that the enclosing loops have been popped correctly 94 assert ( e == loopStmt ); 95 96 // this will take the necessary steps to add definitions of the previous two labels, if they are used. 97 loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) ); 98 enclosingControlStructures.pop_back(); 99 100 return loopStmt; 101 } 102 103 Statement *MLEMutator::mutate( CaseStmt *caseStmt ) { 104 caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) ); 105 fixBlock( caseStmt->get_statements() ); 106 107 return caseStmt; 108 } 109 110 template< typename IfClass > 111 Statement *MLEMutator::handleIfStmt( IfClass *ifStmt ) { 112 // generate a label for breaking out of a labeled if 113 bool labeledBlock = !(ifStmt->get_labels().empty()); 114 if ( labeledBlock ) { 115 Label brkLabel = generator->newLabel("blockBreak", ifStmt); 116 enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) ); 117 } // if 118 119 Parent::mutate( ifStmt ); 120 121 if ( labeledBlock ) { 122 if ( ! enclosingControlStructures.back().useBreakExit().empty() ) { 123 set_breakLabel( enclosingControlStructures.back().useBreakExit() ); 124 } // if 125 enclosingControlStructures.pop_back(); 126 } // if 127 return ifStmt; 128 } 129 130 template< typename SwitchClass > 131 Statement *MLEMutator::handleSwitchStmt( SwitchClass *switchStmt ) { 132 // generate a label for breaking out of a labeled switch 133 Label brkLabel = generator->newLabel("switchBreak", switchStmt); 134 enclosingControlStructures.push_back( Entry(switchStmt, brkLabel) ); 135 mutateAll( switchStmt->get_statements(), *this ); 136 137 Entry &e = enclosingControlStructures.back(); 138 assert ( e == switchStmt ); 139 140 // only generate break label if labeled break is used 141 if ( e.isBreakUsed() ) { 142 // for the purposes of keeping switch statements uniform (i.e. all statements that are direct children of a 143 // switch should be CastStmts), append the exit label + break to the last case statement; create a default 144 // case if there are no cases 145 std::list< Statement * > &statements = switchStmt->get_statements(); 146 if ( statements.empty() ) { 147 statements.push_back( CaseStmt::makeDefault() ); 148 } // if 149 150 if ( CaseStmt * c = dynamic_cast< CaseStmt * >( statements.back() ) ) { 151 Statement * stmt = new BranchStmt( Label("brkLabel"), BranchStmt::Break ); 152 stmt->labels.push_back( brkLabel ); 153 c->get_statements().push_back( stmt ); 154 } else assert(0); // as of this point, all statements of a switch are still CaseStmts 155 } // if 156 157 assert ( enclosingControlStructures.back() == switchStmt ); 158 enclosingControlStructures.pop_back(); 159 return switchStmt; 160 } 78 } 79 161 80 162 81 void addUnused( Statement * stmt, const Label & originalTarget ) { … … 179 98 180 99 181 Statement *MLEMutator:: mutate( BranchStmt *branchStmt ) throw ( SemanticError ) {182 std::string originalTarget = branchStmt-> get_originalTarget();100 Statement *MLEMutator::postmutate( BranchStmt *branchStmt ) throw ( SemanticError ) { 101 std::string originalTarget = branchStmt->originalTarget; 183 102 184 103 std::list< Entry >::reverse_iterator targetEntry; … … 215 134 // branch error checks, get the appropriate label name and create a goto 216 135 Label exitLabel; 217 switch ( branchStmt-> get_type()) {136 switch ( branchStmt->type ) { 218 137 case BranchStmt::Break: 219 138 assert( targetEntry->useBreakExit() != ""); … … 229 148 230 149 // add unused attribute to label to silence warnings 231 addUnused( targetEntry->get_controlStructure(), branchStmt-> get_originalTarget());150 addUnused( targetEntry->get_controlStructure(), branchStmt->originalTarget ); 232 151 233 152 // transform break/continue statements into goto to simplify later handling of branches … … 260 179 } 261 180 262 Statement *MLEMutator::mutate( WhileStmt *whileStmt ) { 263 return handleLoopStmt( whileStmt ); 264 } 265 266 Statement *MLEMutator::mutate( ForStmt *forStmt ) { 267 return handleLoopStmt( forStmt ); 268 } 269 270 Statement *MLEMutator::mutate( IfStmt *ifStmt ) { 271 return handleIfStmt( ifStmt ); 272 } 273 274 Statement *MLEMutator::mutate( SwitchStmt *switchStmt ) { 275 return handleSwitchStmt( switchStmt ); 181 template< typename LoopClass > 182 void MLEMutator::prehandleLoopStmt( LoopClass * loopStmt ) { 183 // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine 184 // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested 185 // loops 186 Label brkLabel = generator->newLabel("loopBreak", loopStmt); 187 Label contLabel = generator->newLabel("loopContinue", loopStmt); 188 enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) ); 189 } 190 191 template< typename LoopClass > 192 Statement * MLEMutator::posthandleLoopStmt( LoopClass * loopStmt ) { 193 assert( ! enclosingControlStructures.empty() ); 194 Entry &e = enclosingControlStructures.back(); 195 // sanity check that the enclosing loops have been popped correctly 196 assert ( e == loopStmt ); 197 198 // this will take the necessary steps to add definitions of the previous two labels, if they are used. 199 loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) ); 200 enclosingControlStructures.pop_back(); 201 return loopStmt; 202 } 203 204 void MLEMutator::premutate( WhileStmt * whileStmt ) { 205 return prehandleLoopStmt( whileStmt ); 206 } 207 208 void MLEMutator::premutate( ForStmt * forStmt ) { 209 return prehandleLoopStmt( forStmt ); 210 } 211 212 Statement * MLEMutator::postmutate( WhileStmt * whileStmt ) { 213 return posthandleLoopStmt( whileStmt ); 214 } 215 216 Statement * MLEMutator::postmutate( ForStmt * forStmt ) { 217 return posthandleLoopStmt( forStmt ); 218 } 219 220 void MLEMutator::premutate( IfStmt * ifStmt ) { 221 // generate a label for breaking out of a labeled if 222 bool labeledBlock = !(ifStmt->get_labels().empty()); 223 if ( labeledBlock ) { 224 Label brkLabel = generator->newLabel("blockBreak", ifStmt); 225 enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) ); 226 } // if 227 } 228 229 Statement * MLEMutator::postmutate( IfStmt * ifStmt ) { 230 bool labeledBlock = !(ifStmt->get_labels().empty()); 231 if ( labeledBlock ) { 232 if ( ! enclosingControlStructures.back().useBreakExit().empty() ) { 233 set_breakLabel( enclosingControlStructures.back().useBreakExit() ); 234 } // if 235 enclosingControlStructures.pop_back(); 236 } // if 237 return ifStmt; 238 } 239 240 void MLEMutator::premutate( CaseStmt *caseStmt ) { 241 visit_children = false; 242 caseStmt->condition = maybeMutate( caseStmt->condition, *visitor ); 243 fixBlock( caseStmt->stmts ); 244 } 245 246 void MLEMutator::premutate( SwitchStmt *switchStmt ) { 247 // generate a label for breaking out of a labeled switch 248 Label brkLabel = generator->newLabel("switchBreak", switchStmt); 249 enclosingControlStructures.push_back( Entry(switchStmt, brkLabel) ); 250 } 251 252 Statement * MLEMutator::postmutate( SwitchStmt * switchStmt ) { 253 Entry &e = enclosingControlStructures.back(); 254 assert ( e == switchStmt ); 255 256 // only generate break label if labeled break is used 257 if ( e.isBreakUsed() ) { 258 // for the purposes of keeping switch statements uniform (i.e. all statements that are direct children of a 259 // switch should be CastStmts), append the exit label + break to the last case statement; create a default 260 // case if there are no cases 261 std::list< Statement * > &statements = switchStmt->statements; 262 if ( statements.empty() ) { 263 statements.push_back( CaseStmt::makeDefault() ); 264 } // if 265 266 if ( CaseStmt * c = dynamic_cast< CaseStmt * >( statements.back() ) ) { 267 Statement * stmt = new BranchStmt( Label("brkLabel"), BranchStmt::Break ); 268 stmt->labels.push_back( e.useBreakExit() ); 269 c->stmts.push_back( stmt ); 270 } else assert(0); // as of this point, all statements of a switch are still CaseStmts 271 } // if 272 273 assert ( enclosingControlStructures.back() == switchStmt ); 274 enclosingControlStructures.pop_back(); 275 return switchStmt; 276 276 } 277 277 } // namespace ControlStruct -
src/ControlStruct/MLEMutator.h
rf792cb8 r7416d46a 20 20 #include <string> // for string 21 21 22 #include "Common/PassVisitor.h" 22 23 #include "Common/SemanticError.h" // for SemanticError 23 24 #include "SynTree/Label.h" // for Label … … 26 27 27 28 namespace ControlStruct { 28 class LabelGenerator;29 class LabelGenerator; 29 30 30 class MLEMutator : public Mutator{31 class MLEMutator : public WithVisitorRef<MLEMutator>, public WithShortCircuiting { 31 32 class Entry; 32 33 33 typedef Mutator Parent;34 34 public: 35 35 MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {} 36 36 ~MLEMutator(); 37 37 38 virtual CompoundStmt *mutate( CompoundStmt *cmpndStmt ) override; 39 virtual Statement *mutate( WhileStmt *whileStmt ) override; 40 virtual Statement *mutate( ForStmt *forStmt ) override; 41 virtual Statement *mutate( BranchStmt *branchStmt ) throw ( SemanticError ) override; 42 virtual Statement *mutate( CaseStmt *caseStmt ) override; 43 virtual Statement *mutate( IfStmt *ifStmt ) override; 44 virtual Statement *mutate( SwitchStmt *switchStmt ) override; 38 void premutate( CompoundStmt *cmpndStmt ); 39 Statement * postmutate( BranchStmt *branchStmt ) throw ( SemanticError ); 40 void premutate( WhileStmt *whileStmt ); 41 Statement * postmutate( WhileStmt *whileStmt ); 42 void premutate( ForStmt *forStmt ); 43 Statement * postmutate( ForStmt *forStmt ); 44 void premutate( CaseStmt *caseStmt ); 45 void premutate( IfStmt *ifStmt ); 46 Statement * postmutate( IfStmt *ifStmt ); 47 void premutate( SwitchStmt *switchStmt ); 48 Statement * postmutate( SwitchStmt *switchStmt ); 45 49 46 50 Statement *mutateLoop( Statement *bodyLoop, Entry &e ); … … 54 58 loop( _loop ), breakExit( _breakExit ), contExit( _contExit ), breakUsed(false), contUsed(false) {} 55 59 56 bool operator==( const Statement *stmt ) { return ( loop == stmt ); }57 bool operator!=( const Statement *stmt ) { return ( loop != stmt ); }60 bool operator==( const Statement *stmt ) { return loop == stmt; } 61 bool operator!=( const Statement *stmt ) { return loop != stmt; } 58 62 59 bool operator==( const Entry &other ) { return ( loop == other.get_controlStructure()); }63 bool operator==( const Entry &other ) { return loop == other.get_controlStructure(); } 60 64 61 65 Statement *get_controlStructure() const { return loop; } … … 78 82 79 83 template< typename LoopClass > 80 Statement *handleLoopStmt( LoopClass *loopStmt );84 void prehandleLoopStmt( LoopClass * loopStmt ); 81 85 82 template< typename IfClass > 83 Statement *handleIfStmt( IfClass *switchStmt ); 84 85 template< typename SwitchClass > 86 Statement *handleSwitchStmt( SwitchClass *switchStmt ); 86 template< typename LoopClass > 87 Statement * posthandleLoopStmt( LoopClass * loopStmt ); 87 88 88 89 void fixBlock( std::list< Statement * > &kids ); -
src/GenPoly/Box.cc
rf792cb8 r7416d46a 302 302 Expression *makeOp( const std::string &name, Expression *arg ) { 303 303 UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) ); 304 expr-> get_args().push_back( arg );304 expr->args.push_back( arg ); 305 305 return expr; 306 306 } … … 309 309 Expression *makeOp( const std::string &name, Expression *lhs, Expression *rhs ) { 310 310 UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) ); 311 expr-> get_args().push_back( lhs );312 expr-> get_args().push_back( rhs );311 expr->args.push_back( lhs ); 312 expr->args.push_back( rhs ); 313 313 return expr; 314 314 } … … 316 316 /// Returns the dereference of a local pointer variable 317 317 Expression *derefVar( ObjectDecl *var ) { 318 return makeOp( "*?",new VariableExpr( var ) );318 return UntypedExpr::createDeref( new VariableExpr( var ) ); 319 319 } 320 320 … … 831 831 if ( ! isPolyType( arg->get_type() ) ) { 832 832 UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) ); 833 deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) ); 834 deref->set_result( arg->get_type()->clone() ); 833 deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) ); 834 deref->result = arg->get_type()->clone(); 835 deref->result->set_lvalue( true ); 835 836 return deref; 836 837 } // if -
src/GenPoly/Lvalue.cc
rf792cb8 r7416d46a 47 47 if ( SymTab::dereferenceOperator ) { 48 48 VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator ); 49 deref-> set_result( new PointerType( Type::Qualifiers(), deref->get_result() ));50 Type * base = InitTweak::getPointerBase( arg-> get_result());51 assertf( base, "expected pointer type in dereference (type was %s)", toString( arg-> get_result()).c_str() );49 deref->result = new PointerType( Type::Qualifiers(), deref->result ); 50 Type * base = InitTweak::getPointerBase( arg->result ); 51 assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->result ).c_str() ); 52 52 ApplicationExpr * ret = new ApplicationExpr( deref, { arg } ); 53 delete ret-> get_result();54 ret-> set_result( base->clone());55 ret-> get_result()->set_lvalue( true );53 delete ret->result; 54 ret->result = base->clone(); 55 ret->result->set_lvalue( true ); 56 56 return ret; 57 57 } else { … … 308 308 int diff = depth1-depth2; 309 309 if ( diff == 0 ) { 310 // conversion between references of the same depth 310 311 assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() ); 311 312 PRINT( std::cerr << castExpr << std::endl; ) 312 313 return castExpr; 313 314 } else if ( diff < 0 ) { 314 Expression * ret = castExpr->get_arg(); 315 // conversion from reference to reference with less depth (e.g. int && -> int &): add dereferences 316 Expression * ret = castExpr->arg; 315 317 for ( int i = 0; i < diff; ++i ) { 316 318 ret = mkDeref( ret ); 317 319 } 318 ret->set_env( castExpr->get_env() ); 319 delete ret->get_result(); 320 ret->set_result( castExpr->get_result() ); 321 castExpr->set_env( nullptr ); 322 castExpr->set_arg( nullptr ); 323 castExpr->set_result( nullptr ); 320 ret->env = castExpr->env; 321 delete ret->result; 322 ret->result = castExpr->result; 323 ret->result->set_lvalue( true ); // ensure result is lvalue 324 castExpr->env = nullptr; 325 castExpr->arg = nullptr; 326 castExpr->result = nullptr; 324 327 delete castExpr; 325 328 return ret; 326 329 } else if ( diff > 0 ) { 327 Expression * ret = castExpr->get_arg(); 330 // conversion from reference to reference with more depth (e.g. int & -> int &&): add address-of 331 Expression * ret = castExpr->arg; 328 332 for ( int i = 0; i < diff; ++i ) { 329 333 ret = new AddressExpr( ret ); 330 334 } 331 ret-> set_env( castExpr->get_env() );332 delete ret-> get_result();333 ret-> set_result( castExpr->get_result() );334 castExpr-> set_env( nullptr );335 castExpr-> set_arg( nullptr );336 castExpr-> set_result( nullptr );335 ret->env = castExpr->env; 336 delete ret->result; 337 ret->result = castExpr->result; 338 castExpr->env = nullptr; 339 castExpr->arg = nullptr; 340 castExpr->result = nullptr; 337 341 delete castExpr; 338 342 return ret; … … 342 346 PRINT( std::cerr << castExpr << std::endl; ) 343 347 return castExpr; 344 } else if ( castExpr-> get_arg()->get_result()->get_lvalue() ) {348 } else if ( castExpr->arg->result->get_lvalue() ) { 345 349 // conversion from lvalue to reference 346 350 // xxx - keep cast, but turn into pointer cast?? … … 348 352 PRINT( 349 353 std::cerr << "convert lvalue to reference -- &" << std::endl; 350 std::cerr << castExpr-> get_arg()<< std::endl;354 std::cerr << castExpr->arg << std::endl; 351 355 ) 352 AddressExpr * ret = new AddressExpr( castExpr-> get_arg());353 if ( refType-> get_base()->get_qualifiers() != castExpr->get_arg()->get_result()->get_qualifiers() ) {356 AddressExpr * ret = new AddressExpr( castExpr->arg ); 357 if ( refType->base->get_qualifiers() != castExpr->arg->result->get_qualifiers() ) { 354 358 // must keep cast if cast-to type is different from the actual type 355 castExpr-> set_arg( ret );359 castExpr->arg = ret; 356 360 return castExpr; 357 361 } 358 ret-> set_env( castExpr->get_env() );359 delete ret-> get_result();360 ret-> set_result( castExpr->get_result() );361 castExpr-> set_env( nullptr );362 castExpr-> set_arg( nullptr );363 castExpr-> set_result( nullptr );362 ret->env = castExpr->env; 363 delete ret->result; 364 ret->result = castExpr->result; 365 castExpr->env = nullptr; 366 castExpr->arg = nullptr; 367 castExpr->result = nullptr; 364 368 delete castExpr; 365 369 return ret; … … 368 372 } 369 373 assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() ); 370 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr-> get_arg()->get_result()) ) {374 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->arg->result ) ) { 371 375 (void)refType; 372 376 // conversion from reference to rvalue … … 375 379 std::cerr << "was = " << castExpr << std::endl; 376 380 ) 377 Expression * ret = castExpr-> get_arg();378 TypeSubstitution * env = castExpr-> get_env();381 Expression * ret = castExpr->arg; 382 TypeSubstitution * env = castExpr->env; 379 383 castExpr->set_env( nullptr ); 380 384 if ( ! isIntrinsicReference( ret ) ) { … … 382 386 ret = mkDeref( ret ); 383 387 } 384 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr-> get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) {388 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->result, castExpr->arg->result->stripReferences(), SymTab::Indexer() ) ) { 385 389 // can remove cast if types are compatible, changing expression type to value type 386 ret->set_result( castExpr->get_result()->clone() ); 387 castExpr->set_arg( nullptr ); 390 ret->result = castExpr->result->clone(); 391 ret->result->set_lvalue( true ); // ensure result is lvalue 392 castExpr->arg = nullptr; 388 393 delete castExpr; 389 394 } else { 390 395 // must keep cast if types are different 391 castExpr-> set_arg( ret );396 castExpr->arg = ret; 392 397 ret = castExpr; 393 398 } -
src/GenPoly/ScrubTyVars.cc
rf792cb8 r7416d46a 25 25 26 26 namespace GenPoly { 27 Type * ScrubTyVars:: mutate( TypeInstType *typeInst ) {27 Type * ScrubTyVars::postmutate( TypeInstType * typeInst ) { 28 28 if ( ! tyVars ) { 29 29 if ( typeInst->get_isFtype() ) { … … 31 31 return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ); 32 32 } else { 33 PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );33 PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) ); 34 34 delete typeInst; 35 35 return ret; … … 37 37 } 38 38 39 TyVarMap::const_iterator tyVar = tyVars->find( typeInst-> get_name());39 TyVarMap::const_iterator tyVar = tyVars->find( typeInst->name ); 40 40 if ( tyVar != tyVars->end() ) { 41 41 switch ( tyVar->second.kind ) { … … 43 43 case TypeDecl::Ttype: 44 44 { 45 PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );45 PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) ); 46 46 delete typeInst; 47 47 return ret; … … 55 55 } 56 56 57 Type * ScrubTyVars::mutateAggregateType( Type * ty ) {57 Type * ScrubTyVars::mutateAggregateType( Type * ty ) { 58 58 if ( shouldScrub( ty ) ) { 59 PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) );59 PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) ); 60 60 delete ty; 61 61 return ret; … … 64 64 } 65 65 66 Type * ScrubTyVars:: mutate( StructInstType *structInst ) {66 Type * ScrubTyVars::postmutate( StructInstType * structInst ) { 67 67 return mutateAggregateType( structInst ); 68 68 } 69 69 70 Type * ScrubTyVars:: mutate( UnionInstType *unionInst ) {70 Type * ScrubTyVars::postmutate( UnionInstType * unionInst ) { 71 71 return mutateAggregateType( unionInst ); 72 72 } 73 73 74 Expression * ScrubTyVars::mutate( SizeofExpr *szeof ) { 74 void ScrubTyVars::primeBaseScrub( Type * type ) { 75 // need to determine whether type needs to be scrubbed to determine whether 76 // automatic recursion is necessary 77 if ( Type * t = shouldScrub( type ) ) { 78 visit_children = false; 79 GuardValue( dynType ); 80 dynType = t; 81 } 82 } 83 84 Expression * ScrubTyVars::postmutate( SizeofExpr * szeof ) { 75 85 // sizeof( T ) => _sizeof_T parameter, which is the size of T 76 if ( Type *dynType = shouldScrub( szeof->get_type() )) {86 if ( dynType ) { 77 87 Expression *expr = new NameExpr( sizeofName( mangleType( dynType ) ) ); 78 88 return expr; 79 } else {80 return Mutator::mutate( szeof );81 89 } // if 90 return szeof; 82 91 } 83 92 84 Expression * ScrubTyVars:: mutate( AlignofExpr *algnof ) {93 Expression * ScrubTyVars::postmutate( AlignofExpr * algnof ) { 85 94 // alignof( T ) => _alignof_T parameter, which is the alignment of T 86 if ( Type *dynType = shouldScrub( algnof->get_type() )) {95 if ( dynType ) { 87 96 Expression *expr = new NameExpr( alignofName( mangleType( dynType ) ) ); 88 97 return expr; 89 } else {90 return Mutator::mutate( algnof );91 98 } // if 99 return algnof; 92 100 } 93 101 94 Type * ScrubTyVars::mutate( PointerType *pointer ) { 95 // // special case of shouldScrub that takes all TypeInstType pointer bases, even if they're not dynamic 96 // Type *base = pointer->get_base(); 97 // Type *dynType = 0; 98 // if ( dynamicOnly ) { 99 // if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( base ) ) { 100 // if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) { dynType = typeInst; } 101 // } else { 102 // dynType = isDynType( base, tyVars ); 103 // } 104 // } else { 105 // dynType = isPolyType( base, tyVars ); 106 // } 107 // if ( dynType ) { 108 if ( Type *dynType = shouldScrub( pointer->get_base() ) ) { 109 Type *ret = dynType->acceptMutator( *this ); 102 Type * ScrubTyVars::postmutate( PointerType * pointer ) { 103 if ( dynType ) { 104 Type * ret = dynType->acceptMutator( *visitor ); 110 105 ret->get_qualifiers() |= pointer->get_qualifiers(); 111 pointer-> set_base( 0 );106 pointer->base = nullptr; 112 107 delete pointer; 113 108 return ret; 114 109 } 115 return Mutator::mutate( pointer );110 return pointer; 116 111 } 117 112 } // namespace GenPoly -
src/GenPoly/ScrubTyVars.h
rf792cb8 r7416d46a 18 18 #include <cassert> // for assert 19 19 20 #include "Common/PassVisitor.h" 20 21 #include "GenPoly.h" // for TyVarMap, isPolyType, isDynType 21 22 #include "SynTree/Mutator.h" // for Mutator … … 27 28 28 29 namespace GenPoly { 29 class ScrubTyVars : public Mutator{30 struct ScrubTyVars : public WithVisitorRef<ScrubTyVars>, public WithShortCircuiting, public WithGuards { 30 31 /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables 31 32 enum ScrubMode { FromMap, DynamicFromMap, All }; … … 51 52 static SynTreeClass *scrubAll( SynTreeClass *target ); 52 53 53 virtual Type* mutate( TypeInstType *typeInst ); 54 virtual Type* mutate( StructInstType *structInst ); 55 virtual Type* mutate( UnionInstType *unionInst ); 56 virtual Expression* mutate( SizeofExpr *szeof ); 57 virtual Expression* mutate( AlignofExpr *algnof ); 58 virtual Type* mutate( PointerType *pointer ); 54 /// determine if children should be visited based on whether base type should be scrubbed. 55 void primeBaseScrub( Type * ); 56 57 void premutate( TypeInstType * ) { visit_children = false; } 58 void premutate( StructInstType * ) { visit_children = false; } 59 void premutate( UnionInstType * ) { visit_children = false; } 60 void premutate( SizeofExpr * szeof ) { primeBaseScrub( szeof->type ); } 61 void premutate( AlignofExpr * algnof ) { primeBaseScrub( algnof->type ); } 62 void premutate( PointerType * pointer ) { primeBaseScrub( pointer->base ); } 63 64 Type * postmutate( TypeInstType * typeInst ); 65 Type * postmutate( StructInstType * structInst ); 66 Type * postmutate( UnionInstType * unionInst ); 67 Expression * postmutate( SizeofExpr * szeof ); 68 Expression * postmutate( AlignofExpr * algnof ); 69 Type * postmutate( PointerType * pointer ); 59 70 60 71 private: … … 75 86 const TyVarMap *tyVars; ///< Type variables to scrub 76 87 ScrubMode mode; ///< which type variables to scrub? [FromMap] 88 89 Type * dynType = nullptr; ///< result of shouldScrub 77 90 }; 78 91 79 92 template< typename SynTreeClass > 80 93 SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) { 81 ScrubTyVarsscrubber( tyVars );94 PassVisitor<ScrubTyVars> scrubber( tyVars ); 82 95 return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) ); 83 96 } … … 85 98 template< typename SynTreeClass > 86 99 SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) { 87 ScrubTyVarsscrubber( tyVars, ScrubTyVars::DynamicFromMap );100 PassVisitor<ScrubTyVars> scrubber( tyVars, ScrubTyVars::DynamicFromMap ); 88 101 return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) ); 89 102 } … … 91 104 template< typename SynTreeClass > 92 105 SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) { 93 ScrubTyVarsscrubber;106 PassVisitor<ScrubTyVars> scrubber; 94 107 return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) ); 95 108 } -
src/InitTweak/FixInit.cc
rf792cb8 r7416d46a 197 197 }; 198 198 199 struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer {199 struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer, public WithVisitorRef<GenStructMemberCalls> { 200 200 /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors 201 201 /// for any member that is missing a corresponding ctor/dtor call. … … 203 203 static void generate( std::list< Declaration * > & translationUnit ); 204 204 205 void previsit( FunctionDecl * funcDecl ); 206 void postvisit( FunctionDecl * funcDecl ); 207 208 void previsit( MemberExpr * memberExpr ); 209 void previsit( ApplicationExpr * appExpr ); 205 void premutate( FunctionDecl * funcDecl ); 206 DeclarationWithType * postmutate( FunctionDecl * funcDecl ); 207 208 void premutate( MemberExpr * memberExpr ); 209 void premutate( ApplicationExpr * appExpr ); 210 211 /// Note: this post mutate used to be in a separate visitor. If this pass breaks, one place to examine is whether it is 212 /// okay for this part of the recursion to occur alongside the rest. 213 Expression * postmutate( UntypedExpr * expr ); 210 214 211 215 SemanticError errors; … … 220 224 bool isCtor = false; // true if current function is a constructor 221 225 StructDecl * structDecl = nullptr; 222 };223 224 // very simple resolver-like mutator class - used to225 // resolve UntypedExprs that are found within newly226 // generated constructor/destructor calls227 class MutatingResolver final : public Mutator {228 public:229 MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {}230 231 using Mutator::mutate;232 virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override;233 virtual Expression* mutate( UntypedExpr *untypedExpr ) override;234 235 private:236 SymTab::Indexer & indexer;237 226 }; 238 227 … … 315 304 void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) { 316 305 PassVisitor<GenStructMemberCalls> warner; 317 acceptAll( translationUnit, warner );306 mutateAll( translationUnit, warner ); 318 307 } 319 308 … … 950 939 } 951 940 952 void GenStructMemberCalls::pre visit( FunctionDecl * funcDecl ) {941 void GenStructMemberCalls::premutate( FunctionDecl * funcDecl ) { 953 942 GuardValue( function ); 954 943 GuardValue( unhandled ); … … 984 973 } 985 974 986 void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {975 DeclarationWithType * GenStructMemberCalls::postmutate( FunctionDecl * funcDecl ) { 987 976 // remove the unhandled objects from usedUninit, because a call is inserted 988 977 // to handle them - only objects that are later constructed are used uninitialized. … … 1038 1027 Statement * callStmt = stmt.front(); 1039 1028 1040 MutatingResolver resolver( indexer );1041 1029 try { 1042 callStmt->acceptMutator( resolver );1030 callStmt->acceptMutator( *visitor ); 1043 1031 if ( isCtor ) { 1044 1032 function->get_statements()->push_front( callStmt ); … … 1056 1044 throw errors; 1057 1045 } 1046 return funcDecl; 1058 1047 } 1059 1048 … … 1081 1070 } 1082 1071 1083 void GenStructMemberCalls::pre visit( ApplicationExpr * appExpr ) {1072 void GenStructMemberCalls::premutate( ApplicationExpr * appExpr ) { 1084 1073 if ( ! checkWarnings( function ) ) { 1085 1074 visit_children = false; … … 1106 1095 } 1107 1096 1108 void GenStructMemberCalls::pre visit( MemberExpr * memberExpr ) {1097 void GenStructMemberCalls::premutate( MemberExpr * memberExpr ) { 1109 1098 if ( ! checkWarnings( function ) || ! isCtor ) { 1110 1099 visit_children = false; … … 1134 1123 } 1135 1124 1136 DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) { 1137 // add object to the indexer assumes that there will be no name collisions 1138 // in generated code. If this changes, add mutate methods for entities with 1139 // scope and call {enter,leave}Scope explicitly. 1140 indexer.addId( objectDecl ); 1141 return objectDecl; 1142 } 1143 1144 Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) { 1125 Expression * GenStructMemberCalls::postmutate( UntypedExpr * untypedExpr ) { 1145 1126 Expression * newExpr = untypedExpr; 1146 1127 ResolvExpr::findVoidExpression( newExpr, indexer ); -
src/ResolvExpr/AlternativeFinder.cc
rf792cb8 r7416d46a 60 60 61 61 namespace ResolvExpr { 62 struct AlternativeFinder::Finder : public WithShortCircuiting { 63 Finder( AlternativeFinder & altFinder ) : altFinder( altFinder ), indexer( altFinder.indexer ), alternatives( altFinder.alternatives ), env( altFinder.env ), targetType( altFinder.targetType ) {} 64 65 void previsit( BaseSyntaxNode * ) { visit_children = false; } 66 67 void postvisit( ApplicationExpr * applicationExpr ); 68 void postvisit( UntypedExpr * untypedExpr ); 69 void postvisit( AddressExpr * addressExpr ); 70 void postvisit( LabelAddressExpr * labelExpr ); 71 void postvisit( CastExpr * castExpr ); 72 void postvisit( VirtualCastExpr * castExpr ); 73 void postvisit( UntypedMemberExpr * memberExpr ); 74 void postvisit( MemberExpr * memberExpr ); 75 void postvisit( NameExpr * variableExpr ); 76 void postvisit( VariableExpr * variableExpr ); 77 void postvisit( ConstantExpr * constantExpr ); 78 void postvisit( SizeofExpr * sizeofExpr ); 79 void postvisit( AlignofExpr * alignofExpr ); 80 void postvisit( UntypedOffsetofExpr * offsetofExpr ); 81 void postvisit( OffsetofExpr * offsetofExpr ); 82 void postvisit( OffsetPackExpr * offsetPackExpr ); 83 void postvisit( AttrExpr * attrExpr ); 84 void postvisit( LogicalExpr * logicalExpr ); 85 void postvisit( ConditionalExpr * conditionalExpr ); 86 void postvisit( CommaExpr * commaExpr ); 87 void postvisit( ImplicitCopyCtorExpr * impCpCtorExpr ); 88 void postvisit( ConstructorExpr * ctorExpr ); 89 void postvisit( RangeExpr * rangeExpr ); 90 void postvisit( UntypedTupleExpr * tupleExpr ); 91 void postvisit( TupleExpr * tupleExpr ); 92 void postvisit( TupleIndexExpr * tupleExpr ); 93 void postvisit( TupleAssignExpr * tupleExpr ); 94 void postvisit( UniqueExpr * unqExpr ); 95 void postvisit( StmtExpr * stmtExpr ); 96 void postvisit( UntypedInitExpr * initExpr ); 97 98 /// Adds alternatives for anonymous members 99 void addAnonConversions( const Alternative & alt ); 100 /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member 101 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); 102 /// Adds alternatives for member expressions where the left side has tuple type 103 void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); 104 /// Adds alternatives for offsetof expressions, given the base type and name of the member 105 template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name ); 106 /// Takes a final result and checks if its assertions can be satisfied 107 template<typename OutputIterator> 108 void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector<ArgPack>& results, OutputIterator out ); 109 /// Finds matching alternatives for a function, given a set of arguments 110 template<typename OutputIterator> 111 void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out ); 112 /// Checks if assertion parameters match for a new alternative 113 template< typename OutputIterator > 114 void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ); 115 private: 116 AlternativeFinder & altFinder; 117 const SymTab::Indexer &indexer; 118 AltList & alternatives; 119 const TypeEnvironment &env; 120 Type *& targetType; 121 }; 122 62 123 Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) { 63 124 CastExpr *castToVoid = new CastExpr( expr ); … … 152 213 153 214 void renameTypes( Expression *expr ) { 154 expr->get_result()->accept( global_renamer);215 renameTyVars( expr->result ); 155 216 } 156 217 } // namespace … … 185 246 186 247 void AlternativeFinder::find( Expression *expr, bool adjust, bool prune, bool failFast ) { 187 expr->accept( *this ); 248 PassVisitor<Finder> finder( *this ); 249 expr->accept( finder ); 188 250 if ( failFast && alternatives.empty() ) { 189 251 PRINT( … … 244 306 } 245 307 246 void AlternativeFinder:: addAnonConversions( const Alternative & alt ) {308 void AlternativeFinder::Finder::addAnonConversions( const Alternative & alt ) { 247 309 // adds anonymous member interpretations whenever an aggregate value type is seen. 248 310 // 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 327 266 328 template< typename StructOrUnionType > 267 void AlternativeFinder:: addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {329 void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { 268 330 // by this point, member must be a name expr 269 331 NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ); … … 284 346 } 285 347 286 void AlternativeFinder:: addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {348 void AlternativeFinder::Finder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { 287 349 if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) { 288 350 // 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 370 } 309 371 310 void AlternativeFinder:: visit( ApplicationExpr *applicationExpr ) {372 void AlternativeFinder::Finder::postvisit( ApplicationExpr *applicationExpr ) { 311 373 alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) ); 312 374 } … … 485 547 Type *adjType = candidate->get_type()->clone(); 486 548 adjustExprType( adjType, newEnv, indexer ); 487 adjType->accept( global_renamer);549 renameTyVars( adjType ); 488 550 PRINT( 489 551 std::cerr << "unifying "; … … 541 603 542 604 template< typename OutputIterator > 543 void AlternativeFinder:: inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) {605 void AlternativeFinder::Finder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) { 544 606 // PRINT( 545 607 // std::cerr << "inferParameters: assertions needed are" << std::endl; … … 595 657 596 658 ArgPack() 597 : parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0), 659 : parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0), 598 660 tupleStart(0), nextExpl(0), explAlt(0) {} 599 661 … … 706 768 707 769 if ( nTuples > 0 || ! results[i].expr ) { 708 // first iteration or no expression to clone, 770 // first iteration or no expression to clone, 709 771 // push empty tuple expression 710 772 newResult.parent = i; … … 892 954 893 955 template<typename OutputIterator> 894 void AlternativeFinder:: validateFunctionAlternative( const Alternative &func, ArgPack& result,956 void AlternativeFinder::Finder::validateFunctionAlternative( const Alternative &func, ArgPack& result, 895 957 const std::vector<ArgPack>& results, OutputIterator out ) { 896 958 ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() ); … … 915 977 916 978 template<typename OutputIterator> 917 void AlternativeFinder:: makeFunctionAlternatives( const Alternative &func,979 void AlternativeFinder::Finder::makeFunctionAlternatives( const Alternative &func, 918 980 FunctionType *funcType, const ExplodedArgs &args, OutputIterator out ) { 919 981 OpenVarSet funcOpenVars; … … 1022 1084 } 1023 1085 1024 void AlternativeFinder:: visit( UntypedExpr *untypedExpr ) {1086 void AlternativeFinder::Finder::postvisit( UntypedExpr *untypedExpr ) { 1025 1087 AlternativeFinder funcFinder( indexer, env ); 1026 1088 funcFinder.findWithAdjustment( untypedExpr->get_function() ); … … 1029 1091 1030 1092 std::vector< AlternativeFinder > argAlternatives; 1031 findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(),1093 altFinder.findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(), 1032 1094 back_inserter( argAlternatives ) ); 1033 1095 1034 1096 // take care of possible tuple assignments 1035 1097 // if not tuple assignment, assignment is taken care of as a normal function call 1036 Tuples::handleTupleAssignment( *this, untypedExpr, argAlternatives );1098 Tuples::handleTupleAssignment( altFinder, untypedExpr, argAlternatives ); 1037 1099 1038 1100 // find function operators … … 1172 1234 // fix this issue in a more robust way. 1173 1235 targetType = nullptr; 1174 visit( untypedExpr );1236 postvisit( untypedExpr ); 1175 1237 } 1176 1238 } … … 1181 1243 } 1182 1244 1183 void AlternativeFinder:: visit( AddressExpr *addressExpr ) {1245 void AlternativeFinder::Finder::postvisit( AddressExpr *addressExpr ) { 1184 1246 AlternativeFinder finder( indexer, env ); 1185 1247 finder.find( addressExpr->get_arg() ); … … 1192 1254 } 1193 1255 1194 void AlternativeFinder:: visit( LabelAddressExpr * expr ) {1256 void AlternativeFinder::Finder::postvisit( LabelAddressExpr * expr ) { 1195 1257 alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } ); 1196 1258 } … … 1223 1285 } 1224 1286 1225 void AlternativeFinder:: visit( CastExpr *castExpr ) {1287 void AlternativeFinder::Finder::postvisit( CastExpr *castExpr ) { 1226 1288 Type *& toType = castExpr->get_result(); 1227 1289 assert( toType ); … … 1278 1340 } 1279 1341 1280 void AlternativeFinder:: visit( VirtualCastExpr * castExpr ) {1342 void AlternativeFinder::Finder::postvisit( VirtualCastExpr * castExpr ) { 1281 1343 assertf( castExpr->get_result(), "Implicate virtual cast targets not yet supported." ); 1282 1344 AlternativeFinder finder( indexer, env ); … … 1290 1352 } 1291 1353 1292 void AlternativeFinder:: visit( UntypedMemberExpr *memberExpr ) {1354 void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) { 1293 1355 AlternativeFinder funcFinder( indexer, env ); 1294 1356 funcFinder.findWithAdjustment( memberExpr->get_aggregate() ); … … 1312 1374 } 1313 1375 1314 void AlternativeFinder:: visit( MemberExpr *memberExpr ) {1376 void AlternativeFinder::Finder::postvisit( MemberExpr *memberExpr ) { 1315 1377 alternatives.push_back( Alternative( memberExpr->clone(), env, Cost::zero ) ); 1316 1378 } 1317 1379 1318 void AlternativeFinder:: visit( NameExpr *nameExpr ) {1380 void AlternativeFinder::Finder::postvisit( NameExpr *nameExpr ) { 1319 1381 std::list< SymTab::Indexer::IdData > declList; 1320 1382 indexer.lookupId( nameExpr->get_name(), declList ); … … 1337 1399 } 1338 1400 1339 void AlternativeFinder:: visit( VariableExpr *variableExpr ) {1401 void AlternativeFinder::Finder::postvisit( VariableExpr *variableExpr ) { 1340 1402 // not sufficient to clone here, because variable's type may have changed 1341 1403 // since the VariableExpr was originally created. … … 1343 1405 } 1344 1406 1345 void AlternativeFinder:: visit( ConstantExpr *constantExpr ) {1407 void AlternativeFinder::Finder::postvisit( ConstantExpr *constantExpr ) { 1346 1408 alternatives.push_back( Alternative( constantExpr->clone(), env, Cost::zero ) ); 1347 1409 } 1348 1410 1349 void AlternativeFinder:: visit( SizeofExpr *sizeofExpr ) {1411 void AlternativeFinder::Finder::postvisit( SizeofExpr *sizeofExpr ) { 1350 1412 if ( sizeofExpr->get_isType() ) { 1351 1413 Type * newType = sizeofExpr->get_type()->clone(); … … 1368 1430 } 1369 1431 1370 void AlternativeFinder:: visit( AlignofExpr *alignofExpr ) {1432 void AlternativeFinder::Finder::postvisit( AlignofExpr *alignofExpr ) { 1371 1433 if ( alignofExpr->get_isType() ) { 1372 1434 Type * newType = alignofExpr->get_type()->clone(); … … 1390 1452 1391 1453 template< typename StructOrUnionType > 1392 void AlternativeFinder:: addOffsetof( StructOrUnionType *aggInst, const std::string &name ) {1454 void AlternativeFinder::Finder::addOffsetof( StructOrUnionType *aggInst, const std::string &name ) { 1393 1455 std::list< Declaration* > members; 1394 1456 aggInst->lookup( name, members ); … … 1403 1465 } 1404 1466 1405 void AlternativeFinder:: visit( UntypedOffsetofExpr *offsetofExpr ) {1467 void AlternativeFinder::Finder::postvisit( UntypedOffsetofExpr *offsetofExpr ) { 1406 1468 AlternativeFinder funcFinder( indexer, env ); 1407 1469 // xxx - resolveTypeof? … … 1413 1475 } 1414 1476 1415 void AlternativeFinder:: visit( OffsetofExpr *offsetofExpr ) {1477 void AlternativeFinder::Finder::postvisit( OffsetofExpr *offsetofExpr ) { 1416 1478 alternatives.push_back( Alternative( offsetofExpr->clone(), env, Cost::zero ) ); 1417 1479 } 1418 1480 1419 void AlternativeFinder:: visit( OffsetPackExpr *offsetPackExpr ) {1481 void AlternativeFinder::Finder::postvisit( OffsetPackExpr *offsetPackExpr ) { 1420 1482 alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) ); 1421 1483 } … … 1444 1506 } 1445 1507 1446 void AlternativeFinder:: visit( AttrExpr *attrExpr ) {1508 void AlternativeFinder::Finder::postvisit( AttrExpr *attrExpr ) { 1447 1509 // assume no 'pointer-to-attribute' 1448 1510 NameExpr *nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() ); … … 1458 1520 if ( function->get_parameters().size() == 1 ) { 1459 1521 if ( attrExpr->get_isType() ) { 1460 resolveAttr( data, function, attrExpr->get_type(), env, *this);1522 resolveAttr( data, function, attrExpr->get_type(), env, altFinder); 1461 1523 } else { 1462 1524 AlternativeFinder finder( indexer, env ); … … 1464 1526 for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) { 1465 1527 if ( choice->expr->get_result()->size() == 1 ) { 1466 resolveAttr(data, function, choice->expr->get_result(), choice->env, *this);1528 resolveAttr(data, function, choice->expr->get_result(), choice->env, altFinder ); 1467 1529 } // fi 1468 1530 } // for … … 1479 1541 } 1480 1542 1481 void AlternativeFinder:: visit( LogicalExpr *logicalExpr ) {1543 void AlternativeFinder::Finder::postvisit( LogicalExpr *logicalExpr ) { 1482 1544 AlternativeFinder firstFinder( indexer, env ); 1483 1545 firstFinder.findWithAdjustment( logicalExpr->get_arg1() ); 1546 if ( firstFinder.alternatives.empty() ) return; 1547 AlternativeFinder secondFinder( indexer, env ); 1548 secondFinder.findWithAdjustment( logicalExpr->get_arg2() ); 1549 if ( secondFinder.alternatives.empty() ) return; 1484 1550 for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) { 1485 AlternativeFinder secondFinder( indexer, first->env );1486 secondFinder.findWithAdjustment( logicalExpr->get_arg2() );1487 1551 for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) { 1552 TypeEnvironment compositeEnv; 1553 compositeEnv.simpleCombine( first->env ); 1554 compositeEnv.simpleCombine( second->env ); 1555 1488 1556 LogicalExpr *newExpr = new LogicalExpr( first->expr->clone(), second->expr->clone(), logicalExpr->get_isAnd() ); 1489 alternatives.push_back( Alternative( newExpr, second->env, first->cost + second->cost ) );1490 } 1491 } 1492 } 1493 1494 void AlternativeFinder:: visit( ConditionalExpr *conditionalExpr ) {1557 alternatives.push_back( Alternative( newExpr, compositeEnv, first->cost + second->cost ) ); 1558 } 1559 } 1560 } 1561 1562 void AlternativeFinder::Finder::postvisit( ConditionalExpr *conditionalExpr ) { 1495 1563 // find alternatives for condition 1496 1564 AlternativeFinder firstFinder( indexer, env ); 1497 1565 firstFinder.findWithAdjustment( conditionalExpr->get_arg1() ); 1566 if ( firstFinder.alternatives.empty() ) return; 1567 // find alternatives for true expression 1568 AlternativeFinder secondFinder( indexer, env ); 1569 secondFinder.findWithAdjustment( conditionalExpr->get_arg2() ); 1570 if ( secondFinder.alternatives.empty() ) return; 1571 // find alterantives for false expression 1572 AlternativeFinder thirdFinder( indexer, env ); 1573 thirdFinder.findWithAdjustment( conditionalExpr->get_arg3() ); 1574 if ( thirdFinder.alternatives.empty() ) return; 1498 1575 for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) { 1499 // find alternatives for true expression1500 AlternativeFinder secondFinder( indexer, first->env );1501 secondFinder.findWithAdjustment( conditionalExpr->get_arg2() );1502 1576 for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) { 1503 // find alterantives for false expression1504 AlternativeFinder thirdFinder( indexer, second->env );1505 thirdFinder.findWithAdjustment( conditionalExpr->get_arg3() );1506 1577 for ( AltList::const_iterator third = thirdFinder.alternatives.begin(); third != thirdFinder.alternatives.end(); ++third ) { 1578 TypeEnvironment compositeEnv; 1579 compositeEnv.simpleCombine( first->env ); 1580 compositeEnv.simpleCombine( second->env ); 1581 compositeEnv.simpleCombine( third->env ); 1582 1507 1583 // unify true and false types, then infer parameters to produce new alternatives 1508 1584 OpenVarSet openVars; 1509 1585 AssertionSet needAssertions, haveAssertions; 1510 Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost );1586 Alternative newAlt( 0, compositeEnv, first->cost + second->cost + third->cost ); 1511 1587 Type* commonType = nullptr; 1512 1588 if ( unify( second->expr->get_result(), third->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) { … … 1524 1600 } 1525 1601 1526 void AlternativeFinder:: visit( CommaExpr *commaExpr ) {1602 void AlternativeFinder::Finder::postvisit( CommaExpr *commaExpr ) { 1527 1603 TypeEnvironment newEnv( env ); 1528 1604 Expression *newFirstArg = resolveInVoidContext( commaExpr->get_arg1(), indexer, newEnv ); … … 1535 1611 } 1536 1612 1537 void AlternativeFinder:: visit( RangeExpr * rangeExpr ) {1613 void AlternativeFinder::Finder::postvisit( RangeExpr * rangeExpr ) { 1538 1614 // resolve low and high, accept alternatives whose low and high types unify 1539 1615 AlternativeFinder firstFinder( indexer, env ); 1540 1616 firstFinder.findWithAdjustment( rangeExpr->get_low() ); 1617 if ( firstFinder.alternatives.empty() ) return; 1618 AlternativeFinder secondFinder( indexer, env ); 1619 secondFinder.findWithAdjustment( rangeExpr->get_high() ); 1620 if ( secondFinder.alternatives.empty() ) return; 1541 1621 for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) { 1542 AlternativeFinder secondFinder( indexer, first->env );1543 secondFinder.findWithAdjustment( rangeExpr->get_high() );1544 1622 for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) { 1623 TypeEnvironment compositeEnv; 1624 compositeEnv.simpleCombine( first->env ); 1625 compositeEnv.simpleCombine( second->env ); 1545 1626 OpenVarSet openVars; 1546 1627 AssertionSet needAssertions, haveAssertions; 1547 Alternative newAlt( 0, second->env, first->cost + second->cost );1628 Alternative newAlt( 0, compositeEnv, first->cost + second->cost ); 1548 1629 Type* commonType = nullptr; 1549 1630 if ( unify( first->expr->get_result(), second->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) { … … 1557 1638 } 1558 1639 1559 void AlternativeFinder:: visit( UntypedTupleExpr *tupleExpr ) {1640 void AlternativeFinder::Finder::postvisit( UntypedTupleExpr *tupleExpr ) { 1560 1641 std::vector< AlternativeFinder > subExprAlternatives; 1561 findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(),1642 altFinder.findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), 1562 1643 back_inserter( subExprAlternatives ) ); 1563 1644 std::vector< AltList > possibilities; … … 1575 1656 } 1576 1657 1577 void AlternativeFinder:: visit( TupleExpr *tupleExpr ) {1658 void AlternativeFinder::Finder::postvisit( TupleExpr *tupleExpr ) { 1578 1659 alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) ); 1579 1660 } 1580 1661 1581 void AlternativeFinder:: visit( ImplicitCopyCtorExpr * impCpCtorExpr ) {1662 void AlternativeFinder::Finder::postvisit( ImplicitCopyCtorExpr * impCpCtorExpr ) { 1582 1663 alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) ); 1583 1664 } 1584 1665 1585 void AlternativeFinder:: visit( ConstructorExpr * ctorExpr ) {1666 void AlternativeFinder::Finder::postvisit( ConstructorExpr * ctorExpr ) { 1586 1667 AlternativeFinder finder( indexer, env ); 1587 1668 // don't prune here, since it's guaranteed all alternatives will have the same type … … 1593 1674 } 1594 1675 1595 void AlternativeFinder:: visit( TupleIndexExpr *tupleExpr ) {1676 void AlternativeFinder::Finder::postvisit( TupleIndexExpr *tupleExpr ) { 1596 1677 alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) ); 1597 1678 } 1598 1679 1599 void AlternativeFinder:: visit( TupleAssignExpr *tupleAssignExpr ) {1680 void AlternativeFinder::Finder::postvisit( TupleAssignExpr *tupleAssignExpr ) { 1600 1681 alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) ); 1601 1682 } 1602 1683 1603 void AlternativeFinder:: visit( UniqueExpr *unqExpr ) {1684 void AlternativeFinder::Finder::postvisit( UniqueExpr *unqExpr ) { 1604 1685 AlternativeFinder finder( indexer, env ); 1605 1686 finder.findWithAdjustment( unqExpr->get_expr() ); … … 1611 1692 } 1612 1693 1613 void AlternativeFinder:: visit( StmtExpr *stmtExpr ) {1694 void AlternativeFinder::Finder::postvisit( StmtExpr *stmtExpr ) { 1614 1695 StmtExpr * newStmtExpr = stmtExpr->clone(); 1615 1696 ResolvExpr::resolveStmtExpr( newStmtExpr, indexer ); … … 1618 1699 } 1619 1700 1620 void AlternativeFinder:: visit( UntypedInitExpr *initExpr ) {1701 void AlternativeFinder::Finder::postvisit( UntypedInitExpr *initExpr ) { 1621 1702 // handle each option like a cast 1622 1703 AltList candidates; 1623 PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; ) 1704 PRINT( 1705 std::cerr << "untyped init expr: " << initExpr << std::endl; 1706 ) 1624 1707 // O(N^2) checks of d-types with e-types 1625 1708 for ( InitAlternative & initAlt : initExpr->get_initAlts() ) { … … 1637 1720 AssertionSet needAssertions, haveAssertions; 1638 1721 OpenVarSet openVars; // find things in env that don't have a "representative type" and claim those are open vars? 1639 PRINT( std::cerr << " @ " << toType << " " << initAlt.designation << std::endl; ) 1722 PRINT( 1723 std::cerr << " @ " << toType << " " << initAlt.designation << std::endl; 1724 ) 1640 1725 // It's possible that a cast can throw away some values in a multiply-valued expression. (An example is a 1641 1726 // cast-to-void, which casts from one value to zero.) Figure out the prefix of the subexpression results -
src/ResolvExpr/AlternativeFinder.h
rf792cb8 r7416d46a 38 38 using ExplodedArgs = std::vector< std::vector< ExplodedActual > >; 39 39 40 class AlternativeFinder : public Visitor{40 class AlternativeFinder { 41 41 public: 42 42 AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env ); … … 94 94 void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out ); 95 95 private: 96 virtual void visit( ApplicationExpr *applicationExpr ); 97 virtual void visit( UntypedExpr *untypedExpr ); 98 virtual void visit( AddressExpr *addressExpr ); 99 virtual void visit( LabelAddressExpr *labelExpr ); 100 virtual void visit( CastExpr *castExpr ); 101 virtual void visit( VirtualCastExpr *castExpr ); 102 virtual void visit( UntypedMemberExpr *memberExpr ); 103 virtual void visit( MemberExpr *memberExpr ); 104 virtual void visit( NameExpr *variableExpr ); 105 virtual void visit( VariableExpr *variableExpr ); 106 virtual void visit( ConstantExpr *constantExpr ); 107 virtual void visit( SizeofExpr *sizeofExpr ); 108 virtual void visit( AlignofExpr *alignofExpr ); 109 virtual void visit( UntypedOffsetofExpr *offsetofExpr ); 110 virtual void visit( OffsetofExpr *offsetofExpr ); 111 virtual void visit( OffsetPackExpr *offsetPackExpr ); 112 virtual void visit( AttrExpr *attrExpr ); 113 virtual void visit( LogicalExpr *logicalExpr ); 114 virtual void visit( ConditionalExpr *conditionalExpr ); 115 virtual void visit( CommaExpr *commaExpr ); 116 virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ); 117 virtual void visit( ConstructorExpr * ctorExpr ); 118 virtual void visit( RangeExpr * rangeExpr ); 119 virtual void visit( UntypedTupleExpr *tupleExpr ); 120 virtual void visit( TupleExpr *tupleExpr ); 121 virtual void visit( TupleIndexExpr *tupleExpr ); 122 virtual void visit( TupleAssignExpr *tupleExpr ); 123 virtual void visit( UniqueExpr *unqExpr ); 124 virtual void visit( StmtExpr *stmtExpr ); 125 virtual void visit( UntypedInitExpr *initExpr ); 126 127 /// Adds alternatives for anonymous members 128 void addAnonConversions( const Alternative & alt ); 129 /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member 130 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); 131 /// Adds alternatives for member expressions where the left side has tuple type 132 void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); 133 /// Adds alternatives for offsetof expressions, given the base type and name of the member 134 template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name ); 135 /// Takes a final result and checks if its assertions can be satisfied 136 template<typename OutputIterator> 137 void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector<ArgPack>& results, OutputIterator out ); 138 /// Finds matching alternatives for a function, given a set of arguments 139 template<typename OutputIterator> 140 void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out ); 141 /// Checks if assertion parameters match for a new alternative 142 template< typename OutputIterator > 143 void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ); 144 96 struct Finder; 145 97 const SymTab::Indexer &indexer; 146 98 AltList alternatives; -
src/ResolvExpr/CastCost.cc
rf792cb8 r7416d46a 31 31 32 32 namespace ResolvExpr { 33 classCastCost : public ConversionCost {33 struct CastCost : public ConversionCost { 34 34 public: 35 CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );35 CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ); 36 36 37 virtual void visit( BasicType *basicType ); 38 virtual void visit( PointerType *pointerType ); 37 using ConversionCost::previsit; 38 using ConversionCost::postvisit; 39 void postvisit( BasicType * basicType ); 40 void postvisit( PointerType * pointerType ); 39 41 }; 40 42 … … 52 54 // all typedefs should be gone by this point 53 55 TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType ); 54 if ( type-> get_base()) {55 return castCost( src, type-> get_base(), indexer, env ) + Cost::safe;56 if ( type->base ) { 57 return castCost( src, type->base, indexer, env ) + Cost::safe; 56 58 } // if 57 59 } // if … … 74 76 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) { 75 77 PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; ) 76 return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer & indexer) {78 return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) { 77 79 return ptrsCastable( t1, t2, env, indexer ); 78 80 }); 79 81 } else { 80 CastCost converter( dest, indexer, env);82 PassVisitor<CastCost> converter( dest, indexer, env, castCost ); 81 83 src->accept( converter ); 82 if ( converter. get_cost() == Cost::infinity ) {84 if ( converter.pass.get_cost() == Cost::infinity ) { 83 85 return Cost::infinity; 84 86 } else { 85 87 // xxx - why are we adding cost 0 here? 86 return converter. get_cost() + Cost::zero;88 return converter.pass.get_cost() + Cost::zero; 87 89 } // if 88 90 } // if 89 91 } 90 92 91 CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )92 : ConversionCost( dest, indexer, env ) {93 CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ) 94 : ConversionCost( dest, indexer, env, costFunc ) { 93 95 } 94 96 95 void CastCost:: visit( BasicType *basicType ) {97 void CastCost::postvisit( BasicType *basicType ) { 96 98 PointerType *destAsPointer = dynamic_cast< PointerType* >( dest ); 97 99 if ( destAsPointer && basicType->isInteger() ) { … … 103 105 } 104 106 105 void CastCost:: visit( PointerType *pointerType ) {107 void CastCost::postvisit( PointerType *pointerType ) { 106 108 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) { 107 if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType-> get_base(), destAsPtr->get_base(), indexer, env ) ) {109 if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) { 108 110 cost = Cost::safe; 109 111 } else { 110 112 TypeEnvironment newEnv( env ); 111 newEnv.add( pointerType-> get_forall());112 newEnv.add( pointerType-> get_base()->get_forall());113 int castResult = ptrsCastable( pointerType-> get_base(), destAsPtr->get_base(), newEnv, indexer );113 newEnv.add( pointerType->forall ); 114 newEnv.add( pointerType->base->forall ); 115 int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer ); 114 116 if ( castResult > 0 ) { 115 117 cost = Cost::safe; -
src/ResolvExpr/CommonType.cc
rf792cb8 r7416d46a 18 18 #include <utility> // for pair 19 19 20 #include "Common/PassVisitor.h" 20 21 #include "ResolvExpr/TypeEnvironment.h" // for OpenVarSet, AssertionSet 21 22 #include "SymTab/Indexer.h" // for Indexer … … 29 30 30 31 namespace ResolvExpr { 31 class CommonType : public Visitor { 32 public: 32 struct CommonType : public WithShortCircuiting { 33 33 CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ); 34 34 Type *get_result() const { return result; } 35 36 void previsit( BaseSyntaxNode * ) { visit_children = false; } 37 38 void postvisit( VoidType * voidType ); 39 void postvisit( BasicType * basicType ); 40 void postvisit( PointerType * pointerType ); 41 void postvisit( ArrayType * arrayType ); 42 void postvisit( ReferenceType * refType ); 43 void postvisit( FunctionType * functionType ); 44 void postvisit( StructInstType * aggregateUseType ); 45 void postvisit( UnionInstType * aggregateUseType ); 46 void postvisit( EnumInstType * aggregateUseType ); 47 void postvisit( TraitInstType * aggregateUseType ); 48 void postvisit( TypeInstType * aggregateUseType ); 49 void postvisit( TupleType * tupleType ); 50 void postvisit( VarArgsType * varArgsType ); 51 void postvisit( ZeroType * zeroType ); 52 void postvisit( OneType * oneType ); 53 35 54 private: 36 virtual void visit( VoidType *voidType );37 virtual void visit( BasicType *basicType );38 virtual void visit( PointerType *pointerType );39 virtual void visit( ArrayType *arrayType );40 virtual void visit( ReferenceType *refType );41 virtual void visit( FunctionType *functionType );42 virtual void visit( StructInstType *aggregateUseType );43 virtual void visit( UnionInstType *aggregateUseType );44 virtual void visit( EnumInstType *aggregateUseType );45 virtual void visit( TraitInstType *aggregateUseType );46 virtual void visit( TypeInstType *aggregateUseType );47 virtual void visit( TupleType *tupleType );48 virtual void visit( VarArgsType *varArgsType );49 virtual void visit( ZeroType *zeroType );50 virtual void visit( OneType *oneType );51 52 55 template< typename Pointer > void getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ); 53 56 template< typename RefType > void handleRefType( RefType *inst, Type *other ); … … 80 83 81 84 Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) { 82 CommonTypevisitor( type2, widenFirst, widenSecond, indexer, env, openVars );85 PassVisitor<CommonType> visitor( type2, widenFirst, widenSecond, indexer, env, openVars ); 83 86 84 87 int depth1 = type1->referenceDepth(); … … 116 119 117 120 type1->accept( visitor ); 118 Type *result = visitor. get_result();121 Type *result = visitor.pass.get_result(); 119 122 if ( ! result ) { 120 123 // this appears to be handling for opaque type declarations … … 188 191 } 189 192 190 void CommonType:: visit( VoidType * ) {}191 192 void CommonType:: visit( BasicType *basicType ) {193 void CommonType::postvisit( VoidType * ) {} 194 195 void CommonType::postvisit( BasicType *basicType ) { 193 196 if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) { 194 197 BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ]; … … 219 222 } 220 223 221 void CommonType:: visit( PointerType *pointerType ) {224 void CommonType::postvisit( PointerType *pointerType ) { 222 225 if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) { 223 226 // std::cerr << "commonType: two pointers: " << pointerType << " / " << otherPointer << std::endl; … … 254 257 } 255 258 256 void CommonType:: visit( ArrayType * ) {}257 258 void CommonType:: visit( ReferenceType *refType ) {259 void CommonType::postvisit( ArrayType * ) {} 260 261 void CommonType::postvisit( ReferenceType *refType ) { 259 262 if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) { 260 263 // std::cerr << "commonType: both references: " << refType << " / " << otherRef << std::endl; … … 291 294 } 292 295 293 void CommonType:: visit( FunctionType * ) {}294 void CommonType:: visit( StructInstType * ) {}295 void CommonType:: visit( UnionInstType * ) {}296 297 void CommonType:: visit( EnumInstType *enumInstType ) {296 void CommonType::postvisit( FunctionType * ) {} 297 void CommonType::postvisit( StructInstType * ) {} 298 void CommonType::postvisit( UnionInstType * ) {} 299 300 void CommonType::postvisit( EnumInstType *enumInstType ) { 298 301 if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) { 299 302 // reuse BasicType, EnumInstType code by swapping type2 with enumInstType 300 ValueGuard< Type * > temp( type2 ); 301 type2 = enumInstType; 302 temp.old->accept( *this ); 303 } // if 304 } 305 306 void CommonType::visit( TraitInstType * ) { 307 } 308 309 void CommonType::visit( TypeInstType *inst ) { 303 result = commonType( type2, enumInstType, widenSecond, widenFirst, indexer, env, openVars ); 304 } // if 305 } 306 307 void CommonType::postvisit( TraitInstType * ) { 308 } 309 310 void CommonType::postvisit( TypeInstType *inst ) { 310 311 if ( widenFirst ) { 311 312 NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ); … … 329 330 } 330 331 331 void CommonType:: visit( TupleType * ) {}332 void CommonType:: visit( VarArgsType * ) {}333 334 void CommonType:: visit( ZeroType *zeroType ) {332 void CommonType::postvisit( TupleType * ) {} 333 void CommonType::postvisit( VarArgsType * ) {} 334 335 void CommonType::postvisit( ZeroType *zeroType ) { 335 336 if ( widenFirst ) { 336 337 if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) { … … 346 347 } 347 348 348 void CommonType:: visit( OneType *oneType ) {349 void CommonType::postvisit( OneType *oneType ) { 349 350 if ( widenFirst ) { 350 351 if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) { -
src/ResolvExpr/ConversionCost.cc
rf792cb8 r7416d46a 44 44 EqvClass eqvClass; 45 45 NamedTypeDecl *namedType; 46 PRINT( std::cerr << "type inst " << destAsTypeInst-> get_name(); )47 if ( env.lookup( destAsTypeInst-> get_name(), eqvClass ) ) {46 PRINT( std::cerr << "type inst " << destAsTypeInst->name; ) 47 if ( env.lookup( destAsTypeInst->name, eqvClass ) ) { 48 48 if ( eqvClass.type ) { 49 49 return conversionCost( src, eqvClass.type, indexer, env ); … … 51 51 return Cost::infinity; 52 52 } 53 } else if ( ( namedType = indexer.lookupType( destAsTypeInst-> get_name()) ) ) {53 } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) { 54 54 PRINT( std::cerr << " found" << std::endl; ) 55 55 TypeDecl *type = dynamic_cast< TypeDecl* >( namedType ); 56 56 // all typedefs should be gone by this point 57 57 assert( type ); 58 if ( type-> get_base()) {59 return conversionCost( src, type-> get_base(), indexer, env ) + Cost::safe;58 if ( type->base ) { 59 return conversionCost( src, type->base, indexer, env ) + Cost::safe; 60 60 } // if 61 61 } // if … … 77 77 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) { 78 78 PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; ) 79 return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer &){79 return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){ 80 80 return ptrsAssignable( t1, t2, env ); 81 81 }); 82 82 } else { 83 ConversionCost converter( dest, indexer, env);83 PassVisitor<ConversionCost> converter( dest, indexer, env, conversionCost ); 84 84 src->accept( converter ); 85 if ( converter. get_cost() == Cost::infinity ) {85 if ( converter.pass.get_cost() == Cost::infinity ) { 86 86 return Cost::infinity; 87 87 } else { 88 return converter. get_cost() + Cost::zero;88 return converter.pass.get_cost() + Cost::zero; 89 89 } // if 90 90 } // if … … 95 95 if ( diff > 0 ) { 96 96 // TODO: document this 97 Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )-> get_base(), dest, diff-1, indexer, env, func );97 Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->base, dest, diff-1, indexer, env, func ); 98 98 cost.incReference(); 99 99 return cost; 100 100 } else if ( diff < -1 ) { 101 101 // TODO: document this 102 Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )-> get_base(), diff+1, indexer, env, func );102 Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->base, diff+1, indexer, env, func ); 103 103 cost.incReference(); 104 104 return cost; … … 108 108 if ( srcAsRef && destAsRef ) { // pointer-like conversions between references 109 109 PRINT( std::cerr << "converting between references" << std::endl; ) 110 Type::Qualifiers tq1 = srcAsRef-> get_base()->get_qualifiers();111 Type::Qualifiers tq2 = destAsRef-> get_base()->get_qualifiers();112 if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef-> get_base(), destAsRef->get_base(), indexer, env ) ) {110 Type::Qualifiers tq1 = srcAsRef->base->get_qualifiers(); 111 Type::Qualifiers tq2 = destAsRef->base->get_qualifiers(); 112 if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->base, destAsRef->base, indexer, env ) ) { 113 113 PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; ) 114 114 if ( tq1 == tq2 ) { … … 120 120 } 121 121 } else { // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right? 122 int assignResult = func( srcAsRef-> get_base(), destAsRef->get_base(), env, indexer);122 int assignResult = func( srcAsRef->base, destAsRef->base, indexer, env ); 123 123 PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; ) 124 124 if ( assignResult > 0 ) { … … 130 130 } else { 131 131 PRINT( std::cerr << "reference to rvalue conversion" << std::endl; ) 132 ConversionCost converter( dest, indexer, env);132 PassVisitor<ConversionCost> converter( dest, indexer, env, conversionCost ); 133 133 src->accept( converter ); 134 return converter. get_cost();134 return converter.pass.get_cost(); 135 135 } // if 136 136 } else { … … 138 138 assert( diff == -1 && destAsRef ); 139 139 PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; ) 140 if ( typesCompatibleIgnoreQualifiers( src, destAsRef-> get_base(), indexer, env ) ) {140 if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) { 141 141 PRINT( std::cerr << "converting compatible base type" << std::endl; ) 142 142 if ( src->get_lvalue() ) { … … 146 146 ) 147 147 // lvalue-to-reference conversion: cv lvalue T => cv T & 148 if ( src->get_qualifiers() == destAsRef-> get_base()->get_qualifiers() ) {148 if ( src->get_qualifiers() == destAsRef->base->get_qualifiers() ) { 149 149 return Cost::reference; // cost needs to be non-zero to add cast 150 } if ( src->get_qualifiers() < destAsRef-> get_base()->get_qualifiers() ) {150 } if ( src->get_qualifiers() < destAsRef->base->get_qualifiers() ) { 151 151 return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same 152 152 } else { 153 153 return Cost::unsafe; 154 154 } // if 155 } else if ( destAsRef-> get_base()->get_const() ) {155 } else if ( destAsRef->base->get_const() ) { 156 156 PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; ) 157 157 // rvalue-to-const-reference conversion: T => const T & … … 173 173 } 174 174 175 ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )176 : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ) {175 ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc ) 176 : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) { 177 177 } 178 178 … … 257 257 }; 258 258 259 void ConversionCost:: visit( VoidType * ) {259 void ConversionCost::postvisit( VoidType * ) { 260 260 cost = Cost::infinity; 261 261 } 262 262 263 void ConversionCost:: visit(BasicType *basicType) {263 void ConversionCost::postvisit(BasicType *basicType) { 264 264 if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) { 265 265 int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ]; … … 278 278 } 279 279 280 void ConversionCost:: visit( PointerType * pointerType ) {280 void ConversionCost::postvisit( PointerType * pointerType ) { 281 281 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) { 282 282 PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; ) 283 Type::Qualifiers tq1 = pointerType-> get_base()->get_qualifiers();284 Type::Qualifiers tq2 = destAsPtr-> get_base()->get_qualifiers();285 if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType-> get_base(), destAsPtr->get_base(), indexer, env ) ) {283 Type::Qualifiers tq1 = pointerType->base->get_qualifiers(); 284 Type::Qualifiers tq2 = destAsPtr->base->get_qualifiers(); 285 if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) { 286 286 PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; ) 287 287 if ( tq1 == tq2 ) { … … 312 312 } 313 313 314 void ConversionCost:: visit( ArrayType * ) {}315 316 void ConversionCost:: visit( ReferenceType * refType ) {314 void ConversionCost::postvisit( ArrayType * ) {} 315 316 void ConversionCost::postvisit( ReferenceType * refType ) { 317 317 // Note: dest can never be a reference, since it would have been caught in an earlier check 318 318 assert( ! dynamic_cast< ReferenceType * >( dest ) ); … … 320 320 // recursively compute conversion cost from T1 to T2. 321 321 // cv can be safely dropped because of 'implicit dereference' behavior. 322 refType->base->accept( *this);322 cost = costFunc( refType->base, dest, indexer, env ); 323 323 if ( refType->base->get_qualifiers() == dest->get_qualifiers() ) { 324 324 cost.incReference(); // prefer exact qualifiers … … 331 331 } 332 332 333 void ConversionCost:: visit( FunctionType * ) {}334 335 void ConversionCost:: visit( StructInstType * inst ) {333 void ConversionCost::postvisit( FunctionType * ) {} 334 335 void ConversionCost::postvisit( StructInstType * inst ) { 336 336 if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) { 337 337 if ( inst->name == destAsInst->name ) { … … 341 341 } 342 342 343 void ConversionCost:: visit( UnionInstType * inst ) {343 void ConversionCost::postvisit( UnionInstType * inst ) { 344 344 if ( UnionInstType *destAsInst = dynamic_cast< UnionInstType* >( dest ) ) { 345 345 if ( inst->name == destAsInst->name ) { … … 349 349 } 350 350 351 void ConversionCost:: visit( EnumInstType * ) {351 void ConversionCost::postvisit( EnumInstType * ) { 352 352 static Type::Qualifiers q; 353 353 static BasicType integer( q, BasicType::SignedInt ); 354 integer.accept( *this); // safe if dest >= int354 cost = costFunc( &integer, dest, indexer, env ); // safe if dest >= int 355 355 if ( cost < Cost::unsafe ) { 356 356 cost.incSafe(); … … 358 358 } 359 359 360 void ConversionCost:: visit( TraitInstType * ) {}361 362 void ConversionCost:: visit( TypeInstType *inst ) {360 void ConversionCost::postvisit( TraitInstType * ) {} 361 362 void ConversionCost::postvisit( TypeInstType *inst ) { 363 363 EqvClass eqvClass; 364 364 NamedTypeDecl *namedType; 365 if ( env.lookup( inst-> get_name(), eqvClass ) ) {366 cost = co nversionCost( eqvClass.type, dest, indexer, env );365 if ( env.lookup( inst->name, eqvClass ) ) { 366 cost = costFunc( eqvClass.type, dest, indexer, env ); 367 367 } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) { 368 if ( inst-> get_name() == destAsInst->get_name()) {368 if ( inst->name == destAsInst->name ) { 369 369 cost = Cost::zero; 370 370 } 371 } else if ( ( namedType = indexer.lookupType( inst-> get_name()) ) ) {371 } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) { 372 372 TypeDecl *type = dynamic_cast< TypeDecl* >( namedType ); 373 373 // all typedefs should be gone by this point 374 374 assert( type ); 375 if ( type-> get_base()) {376 cost = co nversionCost( type->get_base(), dest, indexer, env ) + Cost::safe;377 } // if 378 } // if 379 } 380 381 void ConversionCost:: visit( TupleType * tupleType ) {375 if ( type->base ) { 376 cost = costFunc( type->base, dest, indexer, env ) + Cost::safe; 377 } // if 378 } // if 379 } 380 381 void ConversionCost::postvisit( TupleType * tupleType ) { 382 382 Cost c = Cost::zero; 383 383 if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) { 384 std::list< Type * >::const_iterator srcIt = tupleType-> get_types().begin();385 std::list< Type * >::const_iterator destIt = destAsTuple-> get_types().begin();386 while ( srcIt != tupleType-> get_types().end() && destIt != destAsTuple->get_types().end() ) {387 Cost newCost = co nversionCost( *srcIt++, *destIt++, indexer, env );384 std::list< Type * >::const_iterator srcIt = tupleType->types.begin(); 385 std::list< Type * >::const_iterator destIt = destAsTuple->types.begin(); 386 while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) { 387 Cost newCost = costFunc( *srcIt++, *destIt++, indexer, env ); 388 388 if ( newCost == Cost::infinity ) { 389 389 return; … … 391 391 c += newCost; 392 392 } // while 393 if ( destIt != destAsTuple-> get_types().end() ) {393 if ( destIt != destAsTuple->types.end() ) { 394 394 cost = Cost::infinity; 395 395 } else { … … 399 399 } 400 400 401 void ConversionCost:: visit( VarArgsType * ) {401 void ConversionCost::postvisit( VarArgsType * ) { 402 402 if ( dynamic_cast< VarArgsType* >( dest ) ) { 403 403 cost = Cost::zero; … … 405 405 } 406 406 407 void ConversionCost:: visit( ZeroType * ) {407 void ConversionCost::postvisit( ZeroType * ) { 408 408 if ( dynamic_cast< ZeroType * >( dest ) ) { 409 409 cost = Cost::zero; … … 422 422 } 423 423 424 void ConversionCost:: visit( OneType * ) {424 void ConversionCost::postvisit( OneType * ) { 425 425 if ( dynamic_cast< OneType * >( dest ) ) { 426 426 cost = Cost::zero; -
src/ResolvExpr/ConversionCost.h
rf792cb8 r7416d46a 19 19 20 20 #include "Cost.h" // for Cost 21 22 #include "Common/PassVisitor.h" 21 23 #include "SynTree/Visitor.h" // for Visitor 22 24 #include "SynTree/SynTree.h" // for Visitor Nodes … … 29 31 class TypeEnvironment; 30 32 31 class ConversionCost : public Visitor { 33 typedef std::function<Cost(Type *, Type *, const SymTab::Indexer &, const TypeEnvironment &)> CostFunction; 34 struct ConversionCost : public WithShortCircuiting { 32 35 public: 33 ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );36 ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction ); 34 37 35 38 Cost get_cost() const { return cost; } 36 39 37 virtual void visit(VoidType *voidType); 38 virtual void visit(BasicType *basicType); 39 virtual void visit(PointerType *pointerType); 40 virtual void visit(ArrayType *arrayType); 41 virtual void visit(ReferenceType *refType); 42 virtual void visit(FunctionType *functionType); 43 virtual void visit(StructInstType *aggregateUseType); 44 virtual void visit(UnionInstType *aggregateUseType); 45 virtual void visit(EnumInstType *aggregateUseType); 46 virtual void visit(TraitInstType *aggregateUseType); 47 virtual void visit(TypeInstType *aggregateUseType); 48 virtual void visit(TupleType *tupleType); 49 virtual void visit(VarArgsType *varArgsType); 50 virtual void visit(ZeroType *zeroType); 51 virtual void visit(OneType *oneType); 40 void previsit( BaseSyntaxNode * ) { visit_children = false; } 41 42 void postvisit( VoidType * voidType ); 43 void postvisit( BasicType * basicType ); 44 void postvisit( PointerType * pointerType ); 45 void postvisit( ArrayType * arrayType ); 46 void postvisit( ReferenceType * refType ); 47 void postvisit( FunctionType * functionType ); 48 void postvisit( StructInstType * aggregateUseType ); 49 void postvisit( UnionInstType * aggregateUseType ); 50 void postvisit( EnumInstType * aggregateUseType ); 51 void postvisit( TraitInstType * aggregateUseType ); 52 void postvisit( TypeInstType * aggregateUseType ); 53 void postvisit( TupleType * tupleType ); 54 void postvisit( VarArgsType * varArgsType ); 55 void postvisit( ZeroType * zeroType ); 56 void postvisit( OneType * oneType ); 52 57 protected: 53 58 Type *dest; … … 55 60 Cost cost; 56 61 const TypeEnvironment &env; 62 CostFunction costFunc; 57 63 }; 58 64 59 typedef std::function<int(Type *, Type *, const TypeEnvironment &, const SymTab::Indexer&)> PtrsFunction;65 typedef std::function<int(Type *, Type *, const SymTab::Indexer &, const TypeEnvironment &)> PtrsFunction; 60 66 Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ); 61 67 } // namespace ResolvExpr -
src/ResolvExpr/CurrentObject.cc
rf792cb8 r7416d46a 62 62 virtual ~MemberIterator() {} 63 63 64 /// walks the current object using the given designators as a guide 64 65 virtual void setPosition( std::list< Expression * > & designators ) = 0; 66 67 /// retrieve the list of possible Type/Designaton pairs for the current position in the currect object 65 68 virtual std::list<InitAlternative> operator*() const = 0; 69 70 /// true if the iterator is not currently at the end 66 71 virtual operator bool() const = 0; 72 73 /// moves the iterator by one member in the current object 67 74 virtual MemberIterator & bigStep() = 0; 75 76 /// moves the iterator by one member in the current subobject 68 77 virtual MemberIterator & smallStep() = 0; 78 79 /// the type of the current object 69 80 virtual Type * getType() = 0; 81 82 /// the type of the current subobject 70 83 virtual Type * getNext() = 0; 71 84 85 /// printing for debug 72 86 virtual void print( std::ostream & out, Indenter indent ) const = 0; 73 87 88 /// helper for operator*; aggregates must add designator to each init alternative, but 89 /// adding designators in operator* creates duplicates. 74 90 virtual std::list<InitAlternative> first() const = 0; // should be protected 75 91 }; … … 354 370 } 355 371 } 356 // if ( curMember == std::next( decl->get_members().begin(), 1 ) ) { // xxx - this never triggers because curMember is incremented immediately on construction 357 if ( atbegin ) { // xxx - this never triggers because curMember is incremented immediately on construction 372 if ( atbegin ) { 358 373 // xxx - what about case of empty struct?? 359 374 // only add self if at the very beginning of the structure … … 389 404 return *this; 390 405 } 391 virtual std::list<InitAlternative> first() const { return std::list<InitAlternative>{}; }392 406 }; 393 407 … … 443 457 return new UnionIterator( uit ); 444 458 } else { 445 assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype");459 assertf( dynamic_cast< EnumInstType * >( type ) || dynamic_cast< TypeInstType * >( type ), "Encountered unhandled ReferenceToType in createMemberIterator: %s", toString( type ).c_str() ); 446 460 return new SimpleIterator( type ); 447 461 } -
src/ResolvExpr/PtrsAssignable.cc
rf792cb8 r7416d46a 14 14 // 15 15 16 #include "Common/PassVisitor.h" 16 17 #include "ResolvExpr/TypeEnvironment.h" // for EqvClass, TypeEnvironment 17 18 #include "SynTree/Type.h" // for TypeInstType, Type, BasicType … … 20 21 21 22 namespace ResolvExpr { 22 class PtrsAssignable : public Visitor { 23 public: 23 struct PtrsAssignable : public WithShortCircuiting { 24 24 PtrsAssignable( Type *dest, const TypeEnvironment &env ); 25 25 26 26 int get_result() const { return result; } 27 27 28 virtual void visit( VoidType *voidType ); 29 virtual void visit( BasicType *basicType ); 30 virtual void visit( PointerType *pointerType ); 31 virtual void visit( ArrayType *arrayType ); 32 virtual void visit( FunctionType *functionType ); 33 virtual void visit( StructInstType *inst ); 34 virtual void visit( UnionInstType *inst ); 35 virtual void visit( EnumInstType *inst ); 36 virtual void visit( TraitInstType *inst ); 37 virtual void visit( TypeInstType *inst ); 38 virtual void visit( TupleType *tupleType ); 39 virtual void visit( VarArgsType *varArgsType ); 40 virtual void visit( ZeroType *zeroType ); 41 virtual void visit( OneType *oneType ); 28 void previsit( Type * ) { visit_children = false; } 29 30 void postvisit( VoidType * voidType ); 31 void postvisit( BasicType * basicType ); 32 void postvisit( PointerType * pointerType ); 33 void postvisit( ArrayType * arrayType ); 34 void postvisit( FunctionType * functionType ); 35 void postvisit( StructInstType * inst ); 36 void postvisit( UnionInstType * inst ); 37 void postvisit( EnumInstType * inst ); 38 void postvisit( TraitInstType * inst ); 39 void postvisit( TypeInstType * inst ); 40 void postvisit( TupleType * tupleType ); 41 void postvisit( VarArgsType * varArgsType ); 42 void postvisit( ZeroType * zeroType ); 43 void postvisit( OneType * oneType ); 42 44 private: 43 45 Type *dest; … … 59 61 return -1; 60 62 } else { 61 P trsAssignableptrs( dest, env );63 PassVisitor<PtrsAssignable> ptrs( dest, env ); 62 64 src->accept( ptrs ); 63 return ptrs. get_result();65 return ptrs.pass.get_result(); 64 66 } // if 65 67 } … … 67 69 PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {} 68 70 69 void PtrsAssignable:: visit( VoidType * ) {71 void PtrsAssignable::postvisit( VoidType * ) { 70 72 // T * = void * is disallowed - this is a change from C, where any 71 73 // void * can be assigned or passed to a non-void pointer without a cast. 72 74 } 73 75 74 void PtrsAssignable:: visit( __attribute__((unused)) BasicType *basicType ) {}75 void PtrsAssignable:: visit( __attribute__((unused)) PointerType *pointerType ) {}76 void PtrsAssignable:: visit( __attribute__((unused)) ArrayType *arrayType ) {}77 void PtrsAssignable:: visit( __attribute__((unused)) FunctionType *functionType ) {}76 void PtrsAssignable::postvisit( __attribute__((unused)) BasicType *basicType ) {} 77 void PtrsAssignable::postvisit( __attribute__((unused)) PointerType *pointerType ) {} 78 void PtrsAssignable::postvisit( __attribute__((unused)) ArrayType *arrayType ) {} 79 void PtrsAssignable::postvisit( __attribute__((unused)) FunctionType *functionType ) {} 78 80 79 void PtrsAssignable:: visit( __attribute__((unused)) StructInstType *inst ) {}80 void PtrsAssignable:: visit( __attribute__((unused)) UnionInstType *inst ) {}81 void PtrsAssignable::postvisit( __attribute__((unused)) StructInstType *inst ) {} 82 void PtrsAssignable::postvisit( __attribute__((unused)) UnionInstType *inst ) {} 81 83 82 void PtrsAssignable:: visit( EnumInstType * ) {84 void PtrsAssignable::postvisit( EnumInstType * ) { 83 85 if ( dynamic_cast< BasicType* >( dest ) ) { 84 86 // int * = E *, etc. is safe. This isn't technically correct, as each … … 91 93 } 92 94 93 void PtrsAssignable:: visit( __attribute__((unused)) TraitInstType *inst ) {}94 void PtrsAssignable:: visit( TypeInstType *inst ) {95 void PtrsAssignable::postvisit( __attribute__((unused)) TraitInstType *inst ) {} 96 void PtrsAssignable::postvisit( TypeInstType *inst ) { 95 97 EqvClass eqvClass; 96 98 if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) { … … 100 102 } 101 103 102 void PtrsAssignable:: visit( __attribute__((unused)) TupleType *tupleType ) {}103 void PtrsAssignable:: visit( __attribute__((unused)) VarArgsType *varArgsType ) {}104 void PtrsAssignable:: visit( __attribute__((unused)) ZeroType *zeroType ) {}105 void PtrsAssignable:: visit( __attribute__((unused)) OneType *oneType ) {}104 void PtrsAssignable::postvisit( __attribute__((unused)) TupleType *tupleType ) {} 105 void PtrsAssignable::postvisit( __attribute__((unused)) VarArgsType *varArgsType ) {} 106 void PtrsAssignable::postvisit( __attribute__((unused)) ZeroType *zeroType ) {} 107 void PtrsAssignable::postvisit( __attribute__((unused)) OneType *oneType ) {} 106 108 107 109 } // namespace ResolvExpr -
src/ResolvExpr/PtrsCastable.cc
rf792cb8 r7416d46a 14 14 // 15 15 16 #include "Common/PassVisitor.h" 16 17 #include "ResolvExpr/TypeEnvironment.h" // for EqvClass, TypeEnvironment 17 18 #include "SymTab/Indexer.h" // for Indexer … … 21 22 #include "typeops.h" // for ptrsAssignable 22 23 23 24 24 namespace ResolvExpr { 25 class PtrsCastable : public Visitor{25 struct PtrsCastable : public WithShortCircuiting { 26 26 public: 27 27 PtrsCastable( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ); … … 29 29 int get_result() const { return result; } 30 30 31 virtual void visit(VoidType *voidType); 32 virtual void visit(BasicType *basicType); 33 virtual void visit(PointerType *pointerType); 34 virtual void visit(ArrayType *arrayType); 35 virtual void visit(FunctionType *functionType); 36 virtual void visit(StructInstType *inst); 37 virtual void visit(UnionInstType *inst); 38 virtual void visit(EnumInstType *inst); 39 virtual void visit(TraitInstType *inst); 40 virtual void visit(TypeInstType *inst); 41 virtual void visit(TupleType *tupleType); 42 virtual void visit(VarArgsType *varArgsType); 43 virtual void visit(ZeroType *zeroType); 44 virtual void visit(OneType *oneType); 31 void previsit( Type * ) { visit_children = false; } 32 33 void postvisit( VoidType * voidType ); 34 void postvisit( BasicType * basicType ); 35 void postvisit( PointerType * pointerType ); 36 void postvisit( ArrayType * arrayType ); 37 void postvisit( FunctionType * functionType ); 38 void postvisit( StructInstType * inst ); 39 void postvisit( UnionInstType * inst ); 40 void postvisit( EnumInstType * inst ); 41 void postvisit( TraitInstType * inst ); 42 void postvisit( TypeInstType * inst ); 43 void postvisit( TupleType * tupleType ); 44 void postvisit( VarArgsType * varArgsType ); 45 void postvisit( ZeroType * zeroType ); 46 void postvisit( OneType * oneType ); 45 47 private: 46 48 Type *dest; … … 79 81 EqvClass eqvClass; 80 82 if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) { 83 // xxx - should this be ptrsCastable? 81 84 return ptrsAssignable( src, eqvClass.type, env ); 82 85 } // if … … 85 88 return objectCast( src, env, indexer ); 86 89 } else { 87 P trsCastableptrs( dest, env, indexer );90 PassVisitor<PtrsCastable> ptrs( dest, env, indexer ); 88 91 src->accept( ptrs ); 89 return ptrs. get_result();92 return ptrs.pass.get_result(); 90 93 } // if 91 94 } … … 95 98 } 96 99 97 void PtrsCastable:: visit( VoidType * ) {100 void PtrsCastable::postvisit( VoidType * ) { 98 101 result = objectCast( dest, env, indexer ); 99 102 } 100 103 101 void PtrsCastable:: visit( BasicType * ) {104 void PtrsCastable::postvisit( BasicType * ) { 102 105 result = objectCast( dest, env, indexer ); 103 106 } 104 107 105 void PtrsCastable:: visit( PointerType * ) {108 void PtrsCastable::postvisit( PointerType * ) { 106 109 result = objectCast( dest, env, indexer ); 107 110 } 108 111 109 void PtrsCastable:: visit( ArrayType * ) {112 void PtrsCastable::postvisit( ArrayType * ) { 110 113 result = objectCast( dest, env, indexer ); 111 114 } 112 115 113 void PtrsCastable:: visit( FunctionType * ) {116 void PtrsCastable::postvisit( FunctionType * ) { 114 117 // result = -1; 115 118 result = functionCast( dest, env, indexer ); 116 119 } 117 120 118 void PtrsCastable:: visit( StructInstType * ) {121 void PtrsCastable::postvisit( StructInstType * ) { 119 122 result = objectCast( dest, env, indexer ); 120 123 } 121 124 122 void PtrsCastable:: visit( UnionInstType * ) {125 void PtrsCastable::postvisit( UnionInstType * ) { 123 126 result = objectCast( dest, env, indexer ); 124 127 } 125 128 126 void PtrsCastable:: visit( EnumInstType * ) {129 void PtrsCastable::postvisit( EnumInstType * ) { 127 130 if ( dynamic_cast< EnumInstType* >( dest ) ) { 128 131 result = 1; … … 138 141 } 139 142 140 void PtrsCastable:: visit( TraitInstType * ) {}143 void PtrsCastable::postvisit( TraitInstType * ) {} 141 144 142 void PtrsCastable:: visit(TypeInstType *inst) {145 void PtrsCastable::postvisit(TypeInstType *inst) { 143 146 //result = objectCast( inst, env, indexer ) > 0 && objectCast( dest, env, indexer ) > 0 ? 1 : -1; 144 147 result = objectCast( inst, env, indexer ) == objectCast( dest, env, indexer ) ? 1 : -1; 145 148 } 146 149 147 void PtrsCastable:: visit( TupleType * ) {150 void PtrsCastable::postvisit( TupleType * ) { 148 151 result = objectCast( dest, env, indexer ); 149 152 } 150 153 151 void PtrsCastable:: visit( VarArgsType * ) {154 void PtrsCastable::postvisit( VarArgsType * ) { 152 155 result = objectCast( dest, env, indexer ); 153 156 } 154 157 155 void PtrsCastable:: visit( ZeroType * ) {158 void PtrsCastable::postvisit( ZeroType * ) { 156 159 result = objectCast( dest, env, indexer ); 157 160 } 158 161 159 void PtrsCastable:: visit( OneType * ) {162 void PtrsCastable::postvisit( OneType * ) { 160 163 result = objectCast( dest, env, indexer ); 161 164 } -
src/ResolvExpr/RenameVars.cc
rf792cb8 r7416d46a 19 19 #include <utility> // for pair 20 20 21 #include "Common/PassVisitor.h" 21 22 #include "Common/SemanticError.h" // for SemanticError 22 23 #include "RenameVars.h" … … 27 28 28 29 namespace ResolvExpr { 29 RenameVars global_renamer; 30 namespace { 31 struct RenameVars { 32 RenameVars(); 33 void reset(); 30 34 31 RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) { 32 mapStack.push_front( std::map< std::string, std::string >() ); 35 void previsit( TypeInstType * instType ); 36 void previsit( Type * ); 37 void postvisit( Type * ); 38 39 private: 40 int level, resetCount; 41 std::list< std::map< std::string, std::string > > mapStack; 42 }; 43 44 PassVisitor<RenameVars> global_renamer; 45 } // namespace 46 47 void renameTyVars( Type * t ) { 48 t->accept( global_renamer ); 33 49 } 34 50 35 void RenameVars::reset() { 36 level = 0; 37 resetCount++; 51 void resetTyVarRenaming() { 52 global_renamer.pass.reset(); 38 53 } 39 54 40 void RenameVars::visit( VoidType *voidType ){41 typeBefore( voidType );42 typeAfter( voidType);43 }55 namespace { 56 RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) { 57 mapStack.push_front( std::map< std::string, std::string >() ); 58 } 44 59 45 void RenameVars::visit( BasicType *basicType) {46 typeBefore( basicType );47 typeAfter( basicType );48 }60 void RenameVars::reset() { 61 level = 0; 62 resetCount++; 63 } 49 64 50 void RenameVars::visit( PointerType *pointerType ) { 51 typeBefore( pointerType ); 52 maybeAccept( pointerType->get_base(), *this ); 53 typeAfter( pointerType ); 54 } 65 void RenameVars::previsit( TypeInstType * instType ) { 66 previsit( (Type *)instType ); 67 std::map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->name ); 68 if ( i != mapStack.front().end() ) { 69 instType->name = i->second; 70 } // if 71 } 55 72 56 void RenameVars::visit( ArrayType *arrayType ) { 57 typeBefore( arrayType ); 58 maybeAccept( arrayType->get_dimension(), *this ); 59 maybeAccept( arrayType->get_base(), *this ); 60 typeAfter( arrayType ); 61 } 73 void RenameVars::previsit( Type * type ) { 74 if ( ! type->forall.empty() ) { 75 // copies current name mapping into new mapping 76 mapStack.push_front( mapStack.front() ); 77 // renames all "forall" type names to `_${level}_${name}' 78 for ( auto td : type->forall ) { 79 std::ostringstream output; 80 output << "_" << resetCount << "_" << level << "_" << td->name; 81 std::string newname( output.str() ); 82 mapStack.front()[ td->get_name() ] = newname; 83 td->name = newname; 84 // ditto for assertion names, the next level in 85 level++; 86 // acceptAll( td->assertions, *this ); 87 } // for 88 } // if 89 } 62 90 63 void RenameVars::visit( FunctionType *functionType ) { 64 typeBefore( functionType ); 65 acceptAll( functionType->get_returnVals(), *this ); 66 acceptAll( functionType->get_parameters(), *this ); 67 typeAfter( functionType ); 68 } 69 70 void RenameVars::visit( StructInstType *aggregateUseType ) { 71 typeBefore( aggregateUseType ); 72 acceptAll( aggregateUseType->get_parameters(), *this ); 73 typeAfter( aggregateUseType ); 74 } 75 76 void RenameVars::visit( UnionInstType *aggregateUseType ) { 77 typeBefore( aggregateUseType ); 78 acceptAll( aggregateUseType->get_parameters(), *this ); 79 typeAfter( aggregateUseType ); 80 } 81 82 void RenameVars::visit( EnumInstType *aggregateUseType ) { 83 typeBefore( aggregateUseType ); 84 acceptAll( aggregateUseType->get_parameters(), *this ); 85 typeAfter( aggregateUseType ); 86 } 87 88 void RenameVars::visit( TraitInstType *aggregateUseType ) { 89 typeBefore( aggregateUseType ); 90 acceptAll( aggregateUseType->get_parameters(), *this ); 91 typeAfter( aggregateUseType ); 92 } 93 94 void RenameVars::visit( TypeInstType *instType ) { 95 typeBefore( instType ); 96 std::map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->get_name() ); 97 if ( i != mapStack.front().end() ) { 98 instType->set_name( i->second ); 99 } else { 100 } // if 101 acceptAll( instType->get_parameters(), *this ); 102 typeAfter( instType ); 103 } 104 105 void RenameVars::visit( TupleType *tupleType ) { 106 typeBefore( tupleType ); 107 acceptAll( tupleType->get_types(), *this ); 108 typeAfter( tupleType ); 109 } 110 111 void RenameVars::visit( VarArgsType *varArgsType ) { 112 typeBefore( varArgsType ); 113 typeAfter( varArgsType ); 114 } 115 116 void RenameVars::visit( ZeroType *zeroType ) { 117 typeBefore( zeroType ); 118 typeAfter( zeroType ); 119 } 120 121 void RenameVars::visit( OneType *oneType ) { 122 typeBefore( oneType ); 123 typeAfter( oneType ); 124 } 125 126 void RenameVars::typeBefore( Type *type ) { 127 if ( ! type->get_forall().empty() ) { 128 // copies current name mapping into new mapping 129 mapStack.push_front( mapStack.front() ); 130 // renames all "forall" type names to `_${level}_${name}' 131 for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) { 132 std::ostringstream output; 133 output << "_" << resetCount << "_" << level << "_" << (*i)->get_name(); 134 std::string newname( output.str() ); 135 mapStack.front()[ (*i)->get_name() ] = newname; 136 (*i)->set_name( newname ); 137 // ditto for assertion names, the next level in 138 level++; 139 acceptAll( (*i)->get_assertions(), *this ); 140 } // for 141 } // if 142 } 143 144 void RenameVars::typeAfter( Type *type ) { 145 // clears name mapping added by typeBefore() 146 if ( ! type->get_forall().empty() ) { 147 mapStack.pop_front(); 148 } // if 149 } 150 91 void RenameVars::postvisit( Type * type ) { 92 // clears name mapping added by typeBefore() 93 if ( ! type->forall.empty() ) { 94 mapStack.pop_front(); 95 } // if 96 } 97 } // namespace 151 98 } // namespace ResolvExpr 152 99 -
src/ResolvExpr/RenameVars.h
rf792cb8 r7416d46a 24 24 25 25 namespace ResolvExpr { 26 /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID 27 void renameTyVars( Type * ); 26 28 27 /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID 28 class RenameVars : public Visitor { 29 public: 30 RenameVars(); 31 void reset(); 32 private: 33 virtual void visit( VoidType *basicType ); 34 virtual void visit( BasicType *basicType ); 35 virtual void visit( PointerType *pointerType ); 36 virtual void visit( ArrayType *arrayType ); 37 virtual void visit( FunctionType *functionType ); 38 virtual void visit( StructInstType *aggregateUseType ); 39 virtual void visit( UnionInstType *aggregateUseType ); 40 virtual void visit( EnumInstType *aggregateUseType ); 41 virtual void visit( TraitInstType *aggregateUseType ); 42 virtual void visit( TypeInstType *aggregateUseType ); 43 virtual void visit( TupleType *tupleType ); 44 virtual void visit( VarArgsType *varArgsType ); 45 virtual void visit( ZeroType *zeroType ); 46 virtual void visit( OneType *oneType ); 47 48 void typeBefore( Type *type ); 49 void typeAfter( Type *type ); 50 int level, resetCount; 51 std::list< std::map< std::string, std::string > > mapStack; 52 }; 53 54 extern RenameVars global_renamer; 29 /// resets internal state of renamer to avoid overflow 30 void resetTyVarRenaming(); 55 31 } // namespace ResolvExpr 56 32 -
src/ResolvExpr/Resolver.cc
rf792cb8 r7416d46a 132 132 133 133 void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) { 134 global_renamer.reset();134 resetTyVarRenaming(); 135 135 TypeEnvironment env; 136 136 Expression *newExpr = resolveInVoidContext( untyped, indexer, env ); … … 155 155 } // if 156 156 #endif 157 assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end .");157 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() ); 158 158 Alternative &choice = finder.get_alternatives().front(); 159 159 Expression *newExpr = choice.expr->clone(); … … 171 171 172 172 namespace { 173 /// resolve `untyped` to the expression whose type satisfies `pred` with the lowest cost; kindStr is used for providing better error messages 174 template<typename Pred> 175 void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, Pred pred) { 176 TypeEnvironment env; 177 AlternativeFinder finder( indexer, env ); 178 finder.findWithAdjustment( untyped ); 179 180 AltList candidates; 181 for ( Alternative & alt : finder.get_alternatives() ) { 182 if ( pred( alt.expr->result ) ) { 183 candidates.push_back( std::move( alt ) ); 184 } 185 } 186 187 // choose the lowest cost expression among the candidates 188 AltList winners; 189 findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) ); 190 if ( winners.size() == 0 ) { 191 throw SemanticError( "No reasonable alternatives for " + kindStr + " expression: ", untyped ); 192 } else if ( winners.size() != 1 ) { 193 std::ostringstream stream; 194 stream << "Cannot choose between " << winners.size() << " alternatives for " + kindStr + " expression\n"; 195 untyped->print( stream ); 196 stream << "Alternatives are:\n"; 197 printAlts( winners, stream, 1 ); 198 throw SemanticError( stream.str() ); 199 } 200 201 // there is one unambiguous interpretation - move the expression into the with statement 202 Alternative & alt = winners.front(); 203 finishExpr( alt.expr, alt.env, untyped->env ); 204 delete untyped; 205 untyped = alt.expr; 206 alt.expr = nullptr; 207 } 208 173 209 bool isIntegralType( Type *type ) { 174 210 if ( dynamic_cast< EnumInstType * >( type ) ) { … … 184 220 185 221 void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) { 186 TypeEnvironment env; 187 AlternativeFinder finder( indexer, env ); 188 finder.find( untyped ); 189 #if 0 190 if ( finder.get_alternatives().size() != 1 ) { 191 std::cout << "untyped expr is "; 192 untyped->print( std::cout ); 193 std::cout << std::endl << "alternatives are:"; 194 for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { 195 i->print( std::cout ); 196 } // for 197 } // if 198 #endif 199 Expression *newExpr = 0; 200 const TypeEnvironment *newEnv = 0; 201 for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { 202 if ( i->expr->get_result()->size() == 1 && isIntegralType( i->expr->get_result() ) ) { 203 if ( newExpr ) { 204 throw SemanticError( "Too many interpretations for case control expression", untyped ); 205 } else { 206 newExpr = i->expr->clone(); 207 newEnv = &i->env; 208 } // if 209 } // if 210 } // for 211 if ( ! newExpr ) { 212 throw SemanticError( "No interpretations for case control expression", untyped ); 213 } // if 214 finishExpr( newExpr, *newEnv, untyped->env ); 215 delete untyped; 216 untyped = newExpr; 217 } 218 222 findKindExpression( untyped, indexer, "condition", isIntegralType ); 223 } 219 224 } 220 225 … … 311 316 312 317 void Resolver::previsit( IfStmt *ifStmt ) { 313 find SingleExpression( ifStmt->condition, indexer );318 findIntegralExpression( ifStmt->condition, indexer ); 314 319 } 315 320 316 321 void Resolver::previsit( WhileStmt *whileStmt ) { 317 find SingleExpression( whileStmt->condition, indexer );322 findIntegralExpression( whileStmt->condition, indexer ); 318 323 } 319 324 320 325 void Resolver::previsit( ForStmt *forStmt ) { 321 326 if ( forStmt->condition ) { 322 find SingleExpression( forStmt->condition, indexer );327 findIntegralExpression( forStmt->condition, indexer ); 323 328 } // if 324 329 … … 579 584 } 580 585 586 581 587 void Resolver::previsit( WithStmt * withStmt ) { 582 588 for ( Expression *& expr : withStmt->exprs ) { 583 TypeEnvironment env;584 AlternativeFinder finder( indexer, env );585 finder.findWithAdjustment( expr );586 587 589 // only struct- and union-typed expressions are viable candidates 588 AltList candidates; 589 for ( Alternative & alt : finder.get_alternatives() ) { 590 if ( isStructOrUnion( alt.expr->result ) ) { 591 candidates.push_back( std::move( alt ) ); 592 } 593 } 594 595 // choose the lowest cost expression among the candidates 596 AltList winners; 597 findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) ); 598 if ( winners.size() == 0 ) { 599 throw SemanticError( "No reasonable alternatives for with statement expression: ", expr ); 600 } else if ( winners.size() != 1 ) { 601 std::ostringstream stream; 602 stream << "Cannot choose between " << winners.size() << " alternatives for with statement expression\n"; 603 expr->print( stream ); 604 stream << "Alternatives are:\n"; 605 printAlts( winners, stream, 1 ); 606 throw SemanticError( stream.str() ); 607 } 608 609 // there is one unambiguous interpretation - move the expression into the with statement 610 Alternative & alt = winners.front(); 611 finishExpr( alt.expr, alt.env, expr->env ); 612 delete expr; 613 expr = alt.expr; 614 alt.expr = nullptr; 590 findKindExpression( expr, indexer, "with statement", isStructOrUnion ); 615 591 616 592 // if with expression might be impure, create a temporary so that it is evaluated once -
src/ResolvExpr/Unify.cc
rf792cb8 r7416d46a 44 44 namespace ResolvExpr { 45 45 46 class Unify : public Visitor { 47 public: 46 struct Unify : public WithShortCircuiting { 48 47 Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ); 49 48 50 49 bool get_result() const { return result; } 50 51 void previsit( BaseSyntaxNode * ) { visit_children = false; } 52 53 void postvisit( VoidType * voidType ); 54 void postvisit( BasicType * basicType ); 55 void postvisit( PointerType * pointerType ); 56 void postvisit( ArrayType * arrayType ); 57 void postvisit( ReferenceType * refType ); 58 void postvisit( FunctionType * functionType ); 59 void postvisit( StructInstType * aggregateUseType ); 60 void postvisit( UnionInstType * aggregateUseType ); 61 void postvisit( EnumInstType * aggregateUseType ); 62 void postvisit( TraitInstType * aggregateUseType ); 63 void postvisit( TypeInstType * aggregateUseType ); 64 void postvisit( TupleType * tupleType ); 65 void postvisit( VarArgsType * varArgsType ); 66 void postvisit( ZeroType * zeroType ); 67 void postvisit( OneType * oneType ); 68 51 69 private: 52 virtual void visit(VoidType *voidType);53 virtual void visit(BasicType *basicType);54 virtual void visit(PointerType *pointerType);55 virtual void visit(ArrayType *arrayType);56 virtual void visit(ReferenceType *refType);57 virtual void visit(FunctionType *functionType);58 virtual void visit(StructInstType *aggregateUseType);59 virtual void visit(UnionInstType *aggregateUseType);60 virtual void visit(EnumInstType *aggregateUseType);61 virtual void visit(TraitInstType *aggregateUseType);62 virtual void visit(TypeInstType *aggregateUseType);63 virtual void visit(TupleType *tupleType);64 virtual void visit(VarArgsType *varArgsType);65 virtual void visit(ZeroType *zeroType);66 virtual void visit(OneType *oneType);67 68 70 template< typename RefType > void handleRefType( RefType *inst, Type *other ); 69 71 template< typename RefType > void handleGenericRefType( RefType *inst, Type *other ); … … 325 327 result = bindVar( var2, type1, entry2->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer ); 326 328 } else { 327 Unifycomparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer );329 PassVisitor<Unify> comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer ); 328 330 type1->accept( comparator ); 329 result = comparator. get_result();331 result = comparator.pass.get_result(); 330 332 } // if 331 333 #ifdef DEBUG … … 404 406 } 405 407 406 void Unify:: visit( __attribute__((unused)) VoidType *voidType) {408 void Unify::postvisit( __attribute__((unused)) VoidType *voidType) { 407 409 result = dynamic_cast< VoidType* >( type2 ); 408 410 } 409 411 410 void Unify:: visit(BasicType *basicType) {412 void Unify::postvisit(BasicType *basicType) { 411 413 if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) { 412 414 result = basicType->get_kind() == otherBasic->get_kind(); … … 436 438 } 437 439 438 void Unify:: visit(PointerType *pointerType) {440 void Unify::postvisit(PointerType *pointerType) { 439 441 if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) { 440 442 result = unifyExact( pointerType->get_base(), otherPointer->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); … … 444 446 } 445 447 446 void Unify:: visit(ReferenceType *refType) {448 void Unify::postvisit(ReferenceType *refType) { 447 449 if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) { 448 450 result = unifyExact( refType->get_base(), otherRef->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); … … 452 454 } 453 455 454 void Unify:: visit(ArrayType *arrayType) {456 void Unify::postvisit(ArrayType *arrayType) { 455 457 ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 ); 456 458 // to unify, array types must both be VLA or both not VLA … … 567 569 } 568 570 569 void Unify:: visit(FunctionType *functionType) {571 void Unify::postvisit(FunctionType *functionType) { 570 572 FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 ); 571 573 if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) { … … 669 671 } 670 672 671 void Unify:: visit(StructInstType *structInst) {673 void Unify::postvisit(StructInstType *structInst) { 672 674 handleGenericRefType( structInst, type2 ); 673 675 } 674 676 675 void Unify:: visit(UnionInstType *unionInst) {677 void Unify::postvisit(UnionInstType *unionInst) { 676 678 handleGenericRefType( unionInst, type2 ); 677 679 } 678 680 679 void Unify:: visit(EnumInstType *enumInst) {681 void Unify::postvisit(EnumInstType *enumInst) { 680 682 handleRefType( enumInst, type2 ); 681 683 } 682 684 683 void Unify:: visit(TraitInstType *contextInst) {685 void Unify::postvisit(TraitInstType *contextInst) { 684 686 handleRefType( contextInst, type2 ); 685 687 } 686 688 687 void Unify:: visit(TypeInstType *typeInst) {689 void Unify::postvisit(TypeInstType *typeInst) { 688 690 assert( openVars.find( typeInst->get_name() ) == openVars.end() ); 689 691 TypeInstType *otherInst = dynamic_cast< TypeInstType* >( type2 ); … … 740 742 } 741 743 742 void Unify:: visit(TupleType *tupleType) {744 void Unify::postvisit(TupleType *tupleType) { 743 745 if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) { 744 746 std::unique_ptr<TupleType> flat1( tupleType->clone() ); … … 757 759 } 758 760 759 void Unify:: visit( __attribute__((unused)) VarArgsType *varArgsType ) {761 void Unify::postvisit( __attribute__((unused)) VarArgsType *varArgsType ) { 760 762 result = dynamic_cast< VarArgsType* >( type2 ); 761 763 } 762 764 763 void Unify:: visit( __attribute__((unused)) ZeroType *zeroType ) {765 void Unify::postvisit( __attribute__((unused)) ZeroType *zeroType ) { 764 766 result = dynamic_cast< ZeroType* >( type2 ); 765 767 } 766 768 767 void Unify:: visit( __attribute__((unused)) OneType *oneType ) {769 void Unify::postvisit( __attribute__((unused)) OneType *oneType ) { 768 770 result = dynamic_cast< OneType* >( type2 ); 769 771 } -
src/SymTab/Mangler.cc
rf792cb8 r7416d46a 23 23 24 24 #include "CodeGen/OperatorTable.h" // for OperatorInfo, operatorLookup 25 #include "Common/PassVisitor.h" 25 26 #include "Common/SemanticError.h" // for SemanticError 26 27 #include "Common/utility.h" // for toString … … 31 32 32 33 namespace SymTab { 33 std::string Mangler::mangleType( Type * ty ){34 Mangler mangler( false, true, true );35 maybeAccept( ty, mangler );36 return mangler.get_mangleName();37 }38 39 std::string Mangler::mangleConcrete( Type* ty ) { 40 Mangler mangler( false, false, false );41 maybeAccept( ty, mangler ); 42 return mangler.get_mangleName();43 }44 45 Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams ) 46 : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {}47 48 Mangler::Mangler( const Mangler &rhs ) : mangleName() {49 varNums = rhs.varNums;50 nextVarNum = rhs.nextVarNum;51 isTopLevel = rhs.isTopLevel;52 mangleOverridable = rhs.mangleOverridable;53 typeMode = rhs.typeMode;54 }55 56 void Mangler::mangleDecl( DeclarationWithType * declaration ) {57 bool wasTopLevel = isTopLevel;58 if ( isTopLevel ) {59 varNums.clear();60 nextVarNum = 0; 61 isTopLevel = false;62 } // if63 mangleName << "__";64 CodeGen::OperatorInfo opInfo;65 if ( operatorLookup( declaration->get_name(), opInfo ) ) {66 mangleName << opInfo.outputName;67 } else {68 mangleName << declaration->get_name();69 } // if70 mangleName << "__";71 maybeAccept( declaration->get_type(), *this ); 72 if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {73 // want to be able to override autogenerated and intrinsic routines,74 // so they need a different name mangling 75 if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {76 mangleName << "autogen__";77 } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {78 mangleName << "intrinsic__"; 79 } else{80 // if we add another kind of overridable function, this has to change81 assert( false && "unknown overrideable linkage");82 } // if34 namespace Mangler { 35 namespace { 36 /// Mangles names to a unique C identifier 37 struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler> { 38 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams ); 39 Mangler( const Mangler & ); 40 41 void previsit( BaseSyntaxNode * ) { visit_children = false; } 42 43 void postvisit( ObjectDecl * declaration ); 44 void postvisit( FunctionDecl * declaration ); 45 void postvisit( TypeDecl * declaration ); 46 47 void postvisit( VoidType * voidType ); 48 void postvisit( BasicType * basicType ); 49 void postvisit( PointerType * pointerType ); 50 void postvisit( ArrayType * arrayType ); 51 void postvisit( ReferenceType * refType ); 52 void postvisit( FunctionType * functionType ); 53 void postvisit( StructInstType * aggregateUseType ); 54 void postvisit( UnionInstType * aggregateUseType ); 55 void postvisit( EnumInstType * aggregateUseType ); 56 void postvisit( TypeInstType * aggregateUseType ); 57 void postvisit( TupleType * tupleType ); 58 void postvisit( VarArgsType * varArgsType ); 59 void postvisit( ZeroType * zeroType ); 60 void postvisit( OneType * oneType ); 61 62 std::string get_mangleName() { return mangleName.str(); } 63 private: 64 std::ostringstream mangleName; ///< Mangled name being constructed 65 typedef std::map< std::string, std::pair< int, int > > VarMapType; 66 VarMapType varNums; ///< Map of type variables to indices 67 int nextVarNum; ///< Next type variable index 68 bool isTopLevel; ///< Is the Mangler at the top level 69 bool mangleOverridable; ///< Specially mangle overridable built-in methods 70 bool typeMode; ///< Produce a unique mangled name for a type 71 bool mangleGenericParams; ///< Include generic parameters in name mangling if true 72 73 void mangleDecl( DeclarationWithType *declaration ); 74 void mangleRef( ReferenceToType *refType, std::string prefix ); 75 76 void printQualifiers( Type *type ); 77 }; // Mangler 78 } // namespace 79 80 std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) { 81 PassVisitor<Mangler> mangler( mangleOverridable, typeMode, mangleGenericParams ); 82 maybeAccept( decl, mangler ); 83 return mangler.pass.get_mangleName(); 83 84 } 84 isTopLevel = wasTopLevel; 85 } 86 87 void Mangler::visit( ObjectDecl * declaration ) { 88 mangleDecl( declaration ); 89 } 90 91 void Mangler::visit( FunctionDecl * declaration ) { 92 mangleDecl( declaration ); 93 } 94 95 void Mangler::visit( VoidType * voidType ) { 96 printQualifiers( voidType ); 97 mangleName << "v"; 98 } 99 100 void Mangler::visit( BasicType * basicType ) { 101 static const char *btLetter[] = { 102 "b", // Bool 103 "c", // Char 104 "Sc", // SignedChar 105 "Uc", // UnsignedChar 106 "s", // ShortSignedInt 107 "Us", // ShortUnsignedInt 108 "i", // SignedInt 109 "Ui", // UnsignedInt 110 "l", // LongSignedInt 111 "Ul", // LongUnsignedInt 112 "q", // LongLongSignedInt 113 "Uq", // LongLongUnsignedInt 114 "f", // Float 115 "d", // Double 116 "r", // LongDouble 117 "Xf", // FloatComplex 118 "Xd", // DoubleComplex 119 "Xr", // LongDoubleComplex 120 "If", // FloatImaginary 121 "Id", // DoubleImaginary 122 "Ir", // LongDoubleImaginary 123 "w", // SignedInt128 124 "Uw", // UnsignedInt128 125 }; 126 127 printQualifiers( basicType ); 128 mangleName << btLetter[ basicType->get_kind() ]; 129 } 130 131 void Mangler::visit( PointerType * pointerType ) { 132 printQualifiers( pointerType ); 133 mangleName << "P"; 134 maybeAccept( pointerType->get_base(), *this ); 135 } 136 137 void Mangler::visit( ArrayType * arrayType ) { 138 // TODO: encode dimension 139 printQualifiers( arrayType ); 140 mangleName << "A0"; 141 maybeAccept( arrayType->get_base(), *this ); 142 } 143 144 void Mangler::visit( ReferenceType * refType ) { 145 printQualifiers( refType ); 146 mangleName << "R"; 147 maybeAccept( refType->get_base(), *this ); 148 } 149 150 namespace { 151 inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) { 152 std::list< Type* > ret; 153 std::transform( decls.begin(), decls.end(), std::back_inserter( ret ), 154 std::mem_fun( &DeclarationWithType::get_type ) ); 155 return ret; 85 86 std::string mangleType( Type * ty ) { 87 PassVisitor<Mangler> mangler( false, true, true ); 88 maybeAccept( ty, mangler ); 89 return mangler.pass.get_mangleName(); 156 90 } 157 } 158 159 void Mangler::visit( FunctionType * functionType ) { 160 printQualifiers( functionType ); 161 mangleName << "F"; 162 std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() ); 163 acceptAll( returnTypes, *this ); 164 mangleName << "_"; 165 std::list< Type* > paramTypes = getTypes( functionType->get_parameters() ); 166 acceptAll( paramTypes, *this ); 167 mangleName << "_"; 168 } 169 170 void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) { 171 printQualifiers( refType ); 172 173 mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name(); 174 175 if ( mangleGenericParams ) { 176 std::list< Expression* >& params = refType->get_parameters(); 177 if ( ! params.empty() ) { 91 92 std::string mangleConcrete( Type * ty ) { 93 PassVisitor<Mangler> mangler( false, false, false ); 94 maybeAccept( ty, mangler ); 95 return mangler.pass.get_mangleName(); 96 } 97 98 namespace { 99 Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams ) 100 : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {} 101 102 Mangler::Mangler( const Mangler &rhs ) : mangleName() { 103 varNums = rhs.varNums; 104 nextVarNum = rhs.nextVarNum; 105 isTopLevel = rhs.isTopLevel; 106 mangleOverridable = rhs.mangleOverridable; 107 typeMode = rhs.typeMode; 108 } 109 110 void Mangler::mangleDecl( DeclarationWithType * declaration ) { 111 bool wasTopLevel = isTopLevel; 112 if ( isTopLevel ) { 113 varNums.clear(); 114 nextVarNum = 0; 115 isTopLevel = false; 116 } // if 117 mangleName << "__"; 118 CodeGen::OperatorInfo opInfo; 119 if ( operatorLookup( declaration->get_name(), opInfo ) ) { 120 mangleName << opInfo.outputName; 121 } else { 122 mangleName << declaration->get_name(); 123 } // if 124 mangleName << "__"; 125 maybeAccept( declaration->get_type(), *visitor ); 126 if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) { 127 // want to be able to override autogenerated and intrinsic routines, 128 // so they need a different name mangling 129 if ( declaration->get_linkage() == LinkageSpec::AutoGen ) { 130 mangleName << "autogen__"; 131 } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) { 132 mangleName << "intrinsic__"; 133 } else { 134 // if we add another kind of overridable function, this has to change 135 assert( false && "unknown overrideable linkage" ); 136 } // if 137 } 138 isTopLevel = wasTopLevel; 139 } 140 141 void Mangler::postvisit( ObjectDecl * declaration ) { 142 mangleDecl( declaration ); 143 } 144 145 void Mangler::postvisit( FunctionDecl * declaration ) { 146 mangleDecl( declaration ); 147 } 148 149 void Mangler::postvisit( VoidType * voidType ) { 150 printQualifiers( voidType ); 151 mangleName << "v"; 152 } 153 154 void Mangler::postvisit( BasicType * basicType ) { 155 static const char *btLetter[] = { 156 "b", // Bool 157 "c", // Char 158 "Sc", // SignedChar 159 "Uc", // UnsignedChar 160 "s", // ShortSignedInt 161 "Us", // ShortUnsignedInt 162 "i", // SignedInt 163 "Ui", // UnsignedInt 164 "l", // LongSignedInt 165 "Ul", // LongUnsignedInt 166 "q", // LongLongSignedInt 167 "Uq", // LongLongUnsignedInt 168 "f", // Float 169 "d", // Double 170 "r", // LongDouble 171 "Xf", // FloatComplex 172 "Xd", // DoubleComplex 173 "Xr", // LongDoubleComplex 174 "If", // FloatImaginary 175 "Id", // DoubleImaginary 176 "Ir", // LongDoubleImaginary 177 "w", // SignedInt128 178 "Uw", // UnsignedInt128 179 }; 180 181 printQualifiers( basicType ); 182 mangleName << btLetter[ basicType->get_kind() ]; 183 } 184 185 void Mangler::postvisit( PointerType * pointerType ) { 186 printQualifiers( pointerType ); 187 mangleName << "P"; 188 maybeAccept( pointerType->get_base(), *visitor ); 189 } 190 191 void Mangler::postvisit( ArrayType * arrayType ) { 192 // TODO: encode dimension 193 printQualifiers( arrayType ); 194 mangleName << "A0"; 195 maybeAccept( arrayType->get_base(), *visitor ); 196 } 197 198 void Mangler::postvisit( ReferenceType * refType ) { 199 printQualifiers( refType ); 200 mangleName << "R"; 201 maybeAccept( refType->get_base(), *visitor ); 202 } 203 204 namespace { 205 inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) { 206 std::list< Type* > ret; 207 std::transform( decls.begin(), decls.end(), std::back_inserter( ret ), 208 std::mem_fun( &DeclarationWithType::get_type ) ); 209 return ret; 210 } 211 } 212 213 void Mangler::postvisit( FunctionType * functionType ) { 214 printQualifiers( functionType ); 215 mangleName << "F"; 216 std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() ); 217 acceptAll( returnTypes, *visitor ); 178 218 mangleName << "_"; 179 for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) { 180 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param ); 181 assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str()); 182 maybeAccept( paramType->get_type(), *this ); 219 std::list< Type* > paramTypes = getTypes( functionType->get_parameters() ); 220 acceptAll( paramTypes, *visitor ); 221 mangleName << "_"; 222 } 223 224 void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) { 225 printQualifiers( refType ); 226 227 mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name(); 228 229 if ( mangleGenericParams ) { 230 std::list< Expression* >& params = refType->get_parameters(); 231 if ( ! params.empty() ) { 232 mangleName << "_"; 233 for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) { 234 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param ); 235 assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str()); 236 maybeAccept( paramType->get_type(), *visitor ); 237 } 238 mangleName << "_"; 239 } 183 240 } 241 } 242 243 void Mangler::postvisit( StructInstType * aggregateUseType ) { 244 mangleRef( aggregateUseType, "s" ); 245 } 246 247 void Mangler::postvisit( UnionInstType * aggregateUseType ) { 248 mangleRef( aggregateUseType, "u" ); 249 } 250 251 void Mangler::postvisit( EnumInstType * aggregateUseType ) { 252 mangleRef( aggregateUseType, "e" ); 253 } 254 255 void Mangler::postvisit( TypeInstType * typeInst ) { 256 VarMapType::iterator varNum = varNums.find( typeInst->get_name() ); 257 if ( varNum == varNums.end() ) { 258 mangleRef( typeInst, "t" ); 259 } else { 260 printQualifiers( typeInst ); 261 std::ostringstream numStream; 262 numStream << varNum->second.first; 263 switch ( (TypeDecl::Kind )varNum->second.second ) { 264 case TypeDecl::Dtype: 265 mangleName << "d"; 266 break; 267 case TypeDecl::Ftype: 268 mangleName << "f"; 269 break; 270 case TypeDecl::Ttype: 271 mangleName << "tVARGS"; 272 break; 273 default: 274 assert( false ); 275 } // switch 276 mangleName << numStream.str(); 277 } // if 278 } 279 280 void Mangler::postvisit( TupleType * tupleType ) { 281 printQualifiers( tupleType ); 282 mangleName << "T"; 283 acceptAll( tupleType->types, *visitor ); 184 284 mangleName << "_"; 185 285 } 186 } 187 } 188 189 void Mangler::visit( StructInstType * aggregateUseType ) { 190 mangleRef( aggregateUseType, "s" ); 191 } 192 193 void Mangler::visit( UnionInstType * aggregateUseType ) { 194 mangleRef( aggregateUseType, "u" ); 195 } 196 197 void Mangler::visit( EnumInstType * aggregateUseType ) { 198 mangleRef( aggregateUseType, "e" ); 199 } 200 201 void Mangler::visit( TypeInstType * typeInst ) { 202 VarMapType::iterator varNum = varNums.find( typeInst->get_name() ); 203 if ( varNum == varNums.end() ) { 204 mangleRef( typeInst, "t" ); 205 } else { 206 printQualifiers( typeInst ); 207 std::ostringstream numStream; 208 numStream << varNum->second.first; 209 switch ( (TypeDecl::Kind )varNum->second.second ) { 210 case TypeDecl::Dtype: 211 mangleName << "d"; 212 break; 213 case TypeDecl::Ftype: 214 mangleName << "f"; 215 break; 216 case TypeDecl::Ttype: 217 mangleName << "tVARGS"; 218 break; 219 default: 220 assert( false ); 221 } // switch 222 mangleName << numStream.str(); 223 } // if 224 } 225 226 void Mangler::visit( TupleType * tupleType ) { 227 printQualifiers( tupleType ); 228 mangleName << "T"; 229 acceptAll( tupleType->types, *this ); 230 mangleName << "_"; 231 } 232 233 void Mangler::visit( VarArgsType * varArgsType ) { 234 printQualifiers( varArgsType ); 235 mangleName << "VARGS"; 236 } 237 238 void Mangler::visit( ZeroType * ) { 239 mangleName << "Z"; 240 } 241 242 void Mangler::visit( OneType * ) { 243 mangleName << "O"; 244 } 245 246 void Mangler::visit( TypeDecl * decl ) { 247 static const char *typePrefix[] = { "BT", "BD", "BF" }; 248 mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name; 249 } 250 251 void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) { 252 for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) { 253 os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl; 254 } // for 255 } 256 257 void Mangler::printQualifiers( Type * type ) { 258 // skip if not including qualifiers 259 if ( typeMode ) return; 260 261 if ( ! type->get_forall().empty() ) { 262 std::list< std::string > assertionNames; 263 int tcount = 0, dcount = 0, fcount = 0, vcount = 0; 264 mangleName << "A"; 265 for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) { 266 switch ( (*i)->get_kind() ) { 267 case TypeDecl::Dtype: 268 dcount++; 269 break; 270 case TypeDecl::Ftype: 271 fcount++; 272 break; 273 case TypeDecl::Ttype: 274 vcount++; 275 break; 276 default: 277 assert( false ); 278 } // switch 279 varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() ); 280 for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) { 281 Mangler sub_mangler( mangleOverridable, typeMode, mangleGenericParams ); 282 sub_mangler.nextVarNum = nextVarNum; 283 sub_mangler.isTopLevel = false; 284 sub_mangler.varNums = varNums; 285 (*assert)->accept( sub_mangler ); 286 assertionNames.push_back( sub_mangler.mangleName.str() ); 286 287 void Mangler::postvisit( VarArgsType * varArgsType ) { 288 printQualifiers( varArgsType ); 289 mangleName << "VARGS"; 290 } 291 292 void Mangler::postvisit( ZeroType * ) { 293 mangleName << "Z"; 294 } 295 296 void Mangler::postvisit( OneType * ) { 297 mangleName << "O"; 298 } 299 300 void Mangler::postvisit( TypeDecl * decl ) { 301 static const char *typePrefix[] = { "BT", "BD", "BF" }; 302 mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name; 303 } 304 305 __attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) { 306 for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) { 307 os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl; 287 308 } // for 288 } // for 289 mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_"; 290 std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) ); 291 mangleName << "_"; 292 } // if 293 if ( type->get_const() ) { 294 mangleName << "C"; 295 } // if 296 if ( type->get_volatile() ) { 297 mangleName << "V"; 298 } // if 299 if ( type->get_mutex() ) { 300 mangleName << "M"; 301 } // if 302 // Removed due to restrict not affecting function compatibility in GCC 303 // if ( type->get_isRestrict() ) { 304 // mangleName << "E"; 305 // } // if 306 if ( type->get_lvalue() ) { 307 // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues 308 mangleName << "L"; 309 } 310 if ( type->get_atomic() ) { 311 mangleName << "A"; 312 } // if 313 } 309 } 310 311 void Mangler::printQualifiers( Type * type ) { 312 // skip if not including qualifiers 313 if ( typeMode ) return; 314 315 if ( ! type->get_forall().empty() ) { 316 std::list< std::string > assertionNames; 317 int tcount = 0, dcount = 0, fcount = 0, vcount = 0; 318 mangleName << "A"; 319 for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) { 320 switch ( (*i)->get_kind() ) { 321 case TypeDecl::Dtype: 322 dcount++; 323 break; 324 case TypeDecl::Ftype: 325 fcount++; 326 break; 327 case TypeDecl::Ttype: 328 vcount++; 329 break; 330 default: 331 assert( false ); 332 } // switch 333 varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() ); 334 for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) { 335 PassVisitor<Mangler> sub_mangler( mangleOverridable, typeMode, mangleGenericParams ); 336 sub_mangler.pass.nextVarNum = nextVarNum; 337 sub_mangler.pass.isTopLevel = false; 338 sub_mangler.pass.varNums = varNums; 339 (*assert)->accept( sub_mangler ); 340 assertionNames.push_back( sub_mangler.pass.mangleName.str() ); 341 } // for 342 } // for 343 mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_"; 344 std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) ); 345 mangleName << "_"; 346 } // if 347 if ( type->get_const() ) { 348 mangleName << "C"; 349 } // if 350 if ( type->get_volatile() ) { 351 mangleName << "V"; 352 } // if 353 if ( type->get_mutex() ) { 354 mangleName << "M"; 355 } // if 356 // Removed due to restrict not affecting function compatibility in GCC 357 // if ( type->get_isRestrict() ) { 358 // mangleName << "E"; 359 // } // if 360 if ( type->get_lvalue() ) { 361 // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues 362 mangleName << "L"; 363 } 364 if ( type->get_atomic() ) { 365 mangleName << "A"; 366 } // if 367 } 368 } // namespace 369 } // namespace Mangler 314 370 } // namespace SymTab 315 371 -
src/SymTab/Mangler.h
rf792cb8 r7416d46a 25 25 26 26 namespace SymTab { 27 /// Mangles names to a unique C identifier 28 class Mangler : public Visitor { 29 public: 27 namespace Mangler { 30 28 /// Mangle syntax tree object; primary interface to clients 31 template< typename SynTreeClass >32 static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true ); 29 std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true ); 30 33 31 /// Mangle a type name; secondary interface 34 st atic std::string mangleType( Type* ty );32 std::string mangleType( Type* ty ); 35 33 /// Mangle ignoring generic type parameters 36 static std::string mangleConcrete( Type* ty ); 37 38 39 virtual void visit( ObjectDecl *declaration ); 40 virtual void visit( FunctionDecl *declaration ); 41 virtual void visit( TypeDecl *declaration ); 42 43 virtual void visit( VoidType *voidType ); 44 virtual void visit( BasicType *basicType ); 45 virtual void visit( PointerType *pointerType ); 46 virtual void visit( ArrayType *arrayType ); 47 virtual void visit( ReferenceType *refType ); 48 virtual void visit( FunctionType *functionType ); 49 virtual void visit( StructInstType *aggregateUseType ); 50 virtual void visit( UnionInstType *aggregateUseType ); 51 virtual void visit( EnumInstType *aggregateUseType ); 52 virtual void visit( TypeInstType *aggregateUseType ); 53 virtual void visit( TupleType *tupleType ); 54 virtual void visit( VarArgsType *varArgsType ); 55 virtual void visit( ZeroType *zeroType ); 56 virtual void visit( OneType *oneType ); 57 58 std::string get_mangleName() { return mangleName.str(); } 59 private: 60 std::ostringstream mangleName; ///< Mangled name being constructed 61 typedef std::map< std::string, std::pair< int, int > > VarMapType; 62 VarMapType varNums; ///< Map of type variables to indices 63 int nextVarNum; ///< Next type variable index 64 bool isTopLevel; ///< Is the Mangler at the top level 65 bool mangleOverridable; ///< Specially mangle overridable built-in methods 66 bool typeMode; ///< Produce a unique mangled name for a type 67 bool mangleGenericParams; ///< Include generic parameters in name mangling if true 68 69 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams ); 70 Mangler( const Mangler & ); 71 72 void mangleDecl( DeclarationWithType *declaration ); 73 void mangleRef( ReferenceToType *refType, std::string prefix ); 74 75 void printQualifiers( Type *type ); 76 }; // Mangler 77 78 template< typename SynTreeClass > 79 std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) { 80 Mangler mangler( mangleOverridable, typeMode, mangleGenericParams ); 81 maybeAccept( decl, mangler ); 82 return mangler.get_mangleName(); 83 } 34 std::string mangleConcrete( Type* ty ); 35 } // Mangler 84 36 } // SymTab 85 37 -
src/SynTree/AggregateDecl.cc
rf792cb8 r7416d46a 92 92 } else if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) { 93 93 return constExpr->intValue(); 94 // can be -1, +1, etc. 95 // } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) { 96 // if ( untypedExpr-> ) 94 97 } else { 95 98 assertf( false, "Unhandled expression type in getConstValue for enumerators: %s", toString( expr ).c_str() ); -
src/SynTree/CompoundStmt.cc
rf792cb8 r7416d46a 64 64 } 65 65 if ( ! declMap.empty() ) { 66 VarExprReplacer replacer( declMap ); 67 accept( replacer ); 66 VarExprReplacer::replace( this, declMap ); 68 67 } 69 68 } -
src/SynTree/Expression.cc
rf792cb8 r7416d46a 108 108 // assert( inst->baseEnum ); 109 109 // EnumDecl * decl = inst->baseEnum; 110 // for ( Declaration * member : decl->members ) { 111 // if ( member == _var ) { 112 // type->set_lvalue( false ); 113 // } 110 // long long int value; 111 // if ( decl->valueOf( var, value ) ) { 112 // type->set_lvalue( false ); 114 113 // } 115 114 // } … … 416 415 } else { 417 416 // references have been removed, in which case dereference returns an lvalue of the base type. 418 ret-> get_result()->set_lvalue( true );417 ret->result->set_lvalue( true ); 419 418 } 420 419 } -
src/SynTree/FunctionDecl.cc
rf792cb8 r7416d46a 49 49 } 50 50 if ( ! declMap.empty() ) { 51 VarExprReplacer replacer( declMap ); 52 accept( replacer ); 51 VarExprReplacer::replace( this, declMap ); 53 52 } 54 53 } -
src/SynTree/Label.h
rf792cb8 r7416d46a 33 33 std::list< Attribute * >& get_attributes() { return attributes; } 34 34 35 operator std::string() { return name; }35 operator std::string() const { return name; } 36 36 bool empty() { return name.empty(); } 37 37 private: -
src/SynTree/TypeSubstitution.cc
rf792cb8 r7416d46a 107 107 108 108 void TypeSubstitution::normalize() { 109 PassVisitor<Substituter> sub( *this, true ); 109 110 do { 110 sub Count = 0;111 freeOnly = true;111 sub.pass.subCount = 0; 112 sub.pass.freeOnly = true; 112 113 for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) { 113 i->second = i->second->acceptMutator( *this);114 i->second = i->second->acceptMutator( sub ); 114 115 } 115 } while ( sub Count );116 } 117 118 Type * TypeSubstitution:: mutate( TypeInstType *inst ) {119 BoundVarsType::const_iterator bound = boundVars.find( inst-> get_name());116 } while ( sub.pass.subCount ); 117 } 118 119 Type * TypeSubstitution::Substituter::postmutate( TypeInstType *inst ) { 120 BoundVarsType::const_iterator bound = boundVars.find( inst->name ); 120 121 if ( bound != boundVars.end() ) return inst; 121 122 122 TypeEnvType::const_iterator i = typeEnv.find( inst->get_name() );123 if ( i == typeEnv.end() ) {123 TypeEnvType::const_iterator i = sub.typeEnv.find( inst->get_name() ); 124 if ( i == sub.typeEnv.end() ) { 124 125 return inst; 125 126 } else { 126 /// std::c out<< "found " << inst->get_name() << ", replacing with ";127 /// i->second->print( std::c out);128 /// std::c out<< std::endl;127 /// std::cerr << "found " << inst->get_name() << ", replacing with "; 128 /// i->second->print( std::cerr ); 129 /// std::cerr << std::endl; 129 130 subCount++; 130 Type * newtype = i->second->clone();131 Type * newtype = i->second->clone(); 131 132 newtype->get_qualifiers() |= inst->get_qualifiers(); 132 133 delete inst; … … 135 136 } 136 137 137 Expression * TypeSubstitution:: mutate( NameExpr *nameExpr ) {138 VarEnvType::const_iterator i = varEnv.find( nameExpr->get_name());139 if ( i == varEnv.end() ) {138 Expression * TypeSubstitution::Substituter::postmutate( NameExpr * nameExpr ) { 139 VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name ); 140 if ( i == sub.varEnv.end() ) { 140 141 return nameExpr; 141 142 } else { … … 146 147 } 147 148 148 template< typename TypeClass > 149 Type *TypeSubstitution::handleType( TypeClass *type ) { 150 ValueGuard<BoundVarsType> oldBoundVars( boundVars ); 149 void TypeSubstitution::Substituter::premutate( Type * type ) { 150 GuardValue( boundVars ); 151 151 // bind type variables from forall-qualifiers 152 152 if ( freeOnly ) { 153 for ( Type::ForallList::const_iterator tyvar = type-> get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {154 boundVars.insert( (*tyvar )->get_name());153 for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) { 154 boundVars.insert( (*tyvar)->name ); 155 155 } // for 156 156 } // if 157 Type *ret = Mutator::mutate( type );158 return ret;159 157 } 160 158 161 159 template< typename TypeClass > 162 Type *TypeSubstitution::handleAggregateType( TypeClass *type ) {163 ValueGuard<BoundVarsType> oldBoundVars( boundVars );160 void TypeSubstitution::Substituter::handleAggregateType( TypeClass * type ) { 161 GuardValue( boundVars ); 164 162 // bind type variables from forall-qualifiers 165 163 if ( freeOnly ) { 166 for ( Type::ForallList::const_iterator tyvar = type-> get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {167 boundVars.insert( (*tyvar )->get_name());164 for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) { 165 boundVars.insert( (*tyvar)->name ); 168 166 } // for 169 167 // bind type variables from generic type instantiations 170 168 std::list< TypeDecl* > *baseParameters = type->get_baseParameters(); 171 if ( baseParameters && ! type-> get_parameters().empty() ) {169 if ( baseParameters && ! type->parameters.empty() ) { 172 170 for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters->begin(); tyvar != baseParameters->end(); ++tyvar ) { 173 boundVars.insert( (*tyvar)-> get_name());171 boundVars.insert( (*tyvar)->name ); 174 172 } // for 175 173 } // if 176 174 } // if 177 Type *ret = Mutator::mutate( type ); 178 return ret; 179 } 180 181 Type * TypeSubstitution::mutate( VoidType *voidType ) { 182 return handleType( voidType ); 183 } 184 185 Type * TypeSubstitution::mutate( BasicType *basicType ) { 186 return handleType( basicType ); 187 } 188 189 Type * TypeSubstitution::mutate( PointerType *pointerType ) { 190 return handleType( pointerType ); 191 } 192 193 Type * TypeSubstitution::mutate( ArrayType *arrayType ) { 194 return handleType( arrayType ); 195 } 196 197 Type * TypeSubstitution::mutate( FunctionType *functionType ) { 198 return handleType( functionType ); 199 } 200 201 Type * TypeSubstitution::mutate( StructInstType *aggregateUseType ) { 202 return handleAggregateType( aggregateUseType ); 203 } 204 205 Type * TypeSubstitution::mutate( UnionInstType *aggregateUseType ) { 206 return handleAggregateType( aggregateUseType ); 207 } 208 209 Type * TypeSubstitution::mutate( EnumInstType *aggregateUseType ) { 210 return handleType( aggregateUseType ); 211 } 212 213 Type * TypeSubstitution::mutate( TraitInstType *aggregateUseType ) { 214 return handleType( aggregateUseType ); 215 } 216 217 Type * TypeSubstitution::mutate( TupleType *tupleType ) { 218 return handleType( tupleType ); 219 } 220 221 Type * TypeSubstitution::mutate( VarArgsType *varArgsType ) { 222 return handleType( varArgsType ); 223 } 224 225 Type * TypeSubstitution::mutate( ZeroType *zeroType ) { 226 return handleType( zeroType ); 227 } 228 229 Type * TypeSubstitution::mutate( OneType *oneType ) { 230 return handleType( oneType ); 175 } 176 177 void TypeSubstitution::Substituter::premutate( StructInstType * aggregateUseType ) { 178 handleAggregateType( aggregateUseType ); 179 } 180 181 void TypeSubstitution::Substituter::premutate( UnionInstType *aggregateUseType ) { 182 handleAggregateType( aggregateUseType ); 231 183 } 232 184 -
src/SynTree/TypeSubstitution.h
rf792cb8 r7416d46a 27 27 #include "SynTree/Declaration.h" // for TypeDecl, Declaration (ptr only) 28 28 #include "SynTree/Expression.h" // for Expression (ptr only), NameExpr (p... 29 #include "SynTree/Mutator.h" // for Mutator30 29 #include "SynTree/Type.h" // for Type, ArrayType (ptr only), BasicT... 31 30 32 class TypeSubstitution : public Mutator { 33 typedef Mutator Parent; 31 class TypeSubstitution { 34 32 public: 35 33 TypeSubstitution(); … … 64 62 TypeSubstitution *clone() const { return new TypeSubstitution( *this ); } 65 63 private: 66 virtual Type* mutate(TypeInstType *aggregateUseType);67 virtual Expression* mutate(NameExpr *nameExpr);68 64 69 /// Records type variable bindings from forall-statements 70 template< typename TypeClass > Type *handleType( TypeClass *type ); 71 /// Records type variable bindings from forall-statements and instantiations of generic types 72 template< typename TypeClass > Type *handleAggregateType( TypeClass *type ); 73 74 virtual Type* mutate(VoidType *basicType); 75 virtual Type* mutate(BasicType *basicType); 76 virtual Type* mutate(PointerType *pointerType); 77 virtual Type* mutate(ArrayType *arrayType); 78 virtual Type* mutate(FunctionType *functionType); 79 virtual Type* mutate(StructInstType *aggregateUseType); 80 virtual Type* mutate(UnionInstType *aggregateUseType); 81 virtual Type* mutate(EnumInstType *aggregateUseType); 82 virtual Type* mutate(TraitInstType *aggregateUseType); 83 virtual Type* mutate(TupleType *tupleType); 84 virtual Type* mutate(VarArgsType *varArgsType); 85 virtual Type* mutate(ZeroType *zeroType); 86 virtual Type* mutate(OneType *oneType); 65 // Mutator that performs the substitution 66 struct Substituter; 87 67 88 68 // TODO: worry about traversing into a forall-qualified function type or type decl with assertions … … 97 77 typedef std::map< std::string, Type* > TypeEnvType; 98 78 typedef std::map< std::string, Expression* > VarEnvType; 99 typedef std::set< std::string > BoundVarsType;100 79 TypeEnvType typeEnv; 101 80 VarEnvType varEnv; 102 BoundVarsType boundVars;103 int subCount;104 bool freeOnly;105 81 }; 106 82 … … 134 110 135 111 template< typename FormalIterator, typename ActualIterator > 136 TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) 137 { 112 TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) { 138 113 add( formalBegin, formalEnd, actualBegin ); 139 114 } 115 116 // include needs to happen after TypeSubstitution is defined so that both TypeSubstitution and 117 // PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals. 118 #include "Common/PassVisitor.h" 119 120 // definitition must happen after PassVisitor is included so that WithGuards can be used 121 struct TypeSubstitution::Substituter : public WithGuards { 122 Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {} 123 124 Type * postmutate( TypeInstType * aggregateUseType ); 125 Expression * postmutate( NameExpr * nameExpr ); 126 127 /// Records type variable bindings from forall-statements 128 void premutate( Type * type ); 129 /// Records type variable bindings from forall-statements and instantiations of generic types 130 template< typename TypeClass > void handleAggregateType( TypeClass * type ); 131 132 void premutate( StructInstType * aggregateUseType ); 133 void premutate( UnionInstType * aggregateUseType ); 134 135 TypeSubstitution & sub; 136 int subCount = 0; 137 bool freeOnly; 138 typedef std::set< std::string > BoundVarsType; 139 BoundVarsType boundVars; 140 }; 140 141 141 142 template< typename SynTreeClass > 142 143 int TypeSubstitution::apply( SynTreeClass *&input ) { 143 144 assert( input ); 144 subCount = 0; 145 freeOnly = false; 146 input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) ); 145 PassVisitor<Substituter> sub( *this, false ); 146 input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) ); 147 147 assert( input ); 148 /// std::c out<< "substitution result is: ";149 /// newType->print( std::c out);150 /// std::c out<< std::endl;151 return sub Count;148 /// std::cerr << "substitution result is: "; 149 /// newType->print( std::cerr ); 150 /// std::cerr << std::endl; 151 return sub.pass.subCount; 152 152 } 153 153 … … 155 155 int TypeSubstitution::applyFree( SynTreeClass *&input ) { 156 156 assert( input ); 157 subCount = 0; 158 freeOnly = true; 159 input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) ); 157 PassVisitor<Substituter> sub( *this, true ); 158 input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) ); 160 159 assert( input ); 161 /// std::c out<< "substitution result is: ";162 /// newType->print( std::c out);163 /// std::c out<< std::endl;164 return sub Count;160 /// std::cerr << "substitution result is: "; 161 /// newType->print( std::cerr ); 162 /// std::cerr << std::endl; 163 return sub.pass.subCount; 165 164 } 166 165 -
src/SynTree/VarExprReplacer.cc
rf792cb8 r7416d46a 16 16 #include <iostream> // for operator<<, basic_ostream, ostream, basic_o... 17 17 18 #include "Common/PassVisitor.h" 18 19 #include "Declaration.h" // for operator<<, DeclarationWithType 19 20 #include "Expression.h" // for VariableExpr 20 21 #include "VarExprReplacer.h" 21 22 22 VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {} 23 namespace VarExprReplacer { 24 namespace { 25 /// Visitor that replaces the declarations that VariableExprs refer to, according to the supplied mapping 26 struct VarExprReplacer { 27 private: 28 const DeclMap & declMap; 29 bool debug; 30 public: 31 VarExprReplacer( const DeclMap & declMap, bool debug = false ); 23 32 24 // replace variable with new node from decl map 25 void VarExprReplacer::visit( VariableExpr * varExpr ) { 26 // 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) 27 if ( declMap.count( varExpr->get_var() ) ) { 28 if ( debug ) { 29 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; 33 // replace variable with new node from decl map 34 void previsit( VariableExpr * varExpr ); 35 }; 36 } 37 38 void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) { 39 PassVisitor<VarExprReplacer> replacer( declMap, debug ); 40 maybeAccept( node, replacer ); 41 } 42 43 namespace { 44 VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {} 45 46 // replace variable with new node from decl map 47 void VarExprReplacer::previsit( VariableExpr * varExpr ) { 48 // 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) 49 if ( declMap.count( varExpr->var ) ) { 50 if ( debug ) { 51 std::cerr << "replacing variable reference: " << (void*)varExpr->var << " " << varExpr->var << " with " << (void*)declMap.at( varExpr->var ) << " " << declMap.at( varExpr->var ) << std::endl; 52 } 53 varExpr->var = declMap.at( varExpr->var ); 54 } 30 55 } 31 varExpr->set_var( declMap.at( varExpr->get_var() ) );32 56 } 33 } 57 } // namespace VarExprReplacer 58 59 60 61 62 63 64 -
src/SynTree/VarExprReplacer.h
rf792cb8 r7416d46a 23 23 class VariableExpr; 24 24 25 /// Visitor that replaces the declarations that VariableExprs refer to, according to the supplied mapping 26 class VarExprReplacer : public Visitor { 27 public: 25 namespace VarExprReplacer { 28 26 typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap; 29 private:30 const DeclMap & declMap;31 bool debug;32 public:33 VarExprReplacer( const DeclMap & declMap, bool debug = false );34 27 35 // replace variable with new node from decl map 36 virtual void visit( VariableExpr * varExpr ); 37 38 static void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false ) { 39 VarExprReplacer replacer( declMap, debug ); 40 maybeAccept( node, replacer ); 41 } 42 }; 28 void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false ); 29 } 43 30 44 31 // Local Variables: // -
src/Tuples/TupleExpansion.cc
rf792cb8 r7416d46a 36 36 namespace Tuples { 37 37 namespace { 38 struct MemberTupleExpander final : public Mutator { 39 typedef Mutator Parent; 40 using Parent::mutate; 41 42 virtual Expression * mutate( UntypedMemberExpr * memberExpr ) override; 38 struct MemberTupleExpander final : public WithShortCircuiting, public WithVisitorRef<MemberTupleExpander> { 39 void premutate( UntypedMemberExpr * ) { visit_children = false; } 40 Expression * postmutate( UntypedMemberExpr * memberExpr ); 43 41 }; 44 42 … … 79 77 80 78 void expandMemberTuples( std::list< Declaration * > & translationUnit ) { 81 MemberTupleExpanderexpander;79 PassVisitor<MemberTupleExpander> expander; 82 80 mutateAll( translationUnit, expander ); 83 81 } … … 109 107 // construct a new UntypedMemberExpr with the correct structure , and recursively 110 108 // expand that member expression. 111 MemberTupleExpanderexpander;112 UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr-> get_aggregate(), aggr->clone() );113 UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr-> get_member(), inner );109 PassVisitor<MemberTupleExpander> expander; 110 UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->aggregate, aggr->clone() ); 111 UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member, inner ); 114 112 inner->location = newMemberExpr->location = loc; 115 memberExpr-> set_member(nullptr);116 memberExpr-> set_aggregate(nullptr);113 memberExpr->member = nullptr; 114 memberExpr->aggregate = nullptr; 117 115 delete memberExpr; 118 116 return newMemberExpr->acceptMutator( expander ); … … 126 124 } 127 125 128 Expression * MemberTupleExpander:: mutate( UntypedMemberExpr * memberExpr ) {129 if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr-> get_member()) ) {130 Expression * aggr = memberExpr-> get_aggregate()->clone()->acceptMutator( *this);126 Expression * MemberTupleExpander::postmutate( UntypedMemberExpr * memberExpr ) { 127 if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->member ) ) { 128 Expression * aggr = memberExpr->aggregate->clone()->acceptMutator( *visitor ); 131 129 // aggregate expressions which might be impure must be wrapped in unique expressions 132 130 // 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 133 131 // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr ); 134 132 aggr = new UniqueExpr( aggr ); 135 for ( Expression *& expr : tupleExpr-> get_exprs()) {133 for ( Expression *& expr : tupleExpr->exprs ) { 136 134 expr = reconstructMemberExpr( expr, aggr, memberExpr->location ); 137 135 expr->location = memberExpr->location; … … 143 141 // there may be a tuple expr buried in the aggregate 144 142 // xxx - this is a memory leak 145 UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr-> get_member()->clone(), memberExpr->get_aggregate()->acceptMutator( *this) );143 UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member->clone(), memberExpr->aggregate->acceptMutator( *visitor ) ); 146 144 newMemberExpr->location = memberExpr->location; 147 145 return newMemberExpr; -
src/benchmark/Makefile.am
rf792cb8 r7416d46a 59 59 @echo -e '\t"githash": "'${githash}'",' 60 60 @echo -e '\t"arch": "' ${arch} '",' 61 @echo -e '\t"compile": {' 62 @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :' 63 @echo -e '\t\t"dummy" : {}' 64 @echo -e '\t},' 61 65 @echo -e '\t"ctxswitch": {' 62 66 @echo -en '\t\t"coroutine":' … … 198 202 199 203 waitfor-cfa1$(EXEEXT): 200 ${CC} schedext/cfa1.c -DBENCH_N=500000 -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}204 @${CC} schedext/cfa1.c -DBENCH_N=500000 -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} 201 205 202 206 waitfor-cfa2$(EXEEXT): -
src/benchmark/Makefile.in
rf792cb8 r7416d46a 473 473 @echo -e '\t"githash": "'${githash}'",' 474 474 @echo -e '\t"arch": "' ${arch} '",' 475 @echo -e '\t"compile": {' 476 @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :' 477 @echo -e '\t\t"dummy" : {}' 478 @echo -e '\t},' 475 479 @echo -e '\t"ctxswitch": {' 476 480 @echo -en '\t\t"coroutine":' … … 607 611 608 612 waitfor-cfa1$(EXEEXT): 609 ${CC} schedext/cfa1.c -DBENCH_N=500000 -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}613 @${CC} schedext/cfa1.c -DBENCH_N=500000 -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} 610 614 611 615 waitfor-cfa2$(EXEEXT): -
src/driver/cfa.cc
rf792cb8 r7416d46a 277 277 args[nargs] = "--undefined=__cfaabi_dbg_bits_write"; 278 278 nargs += 1; 279 args[nargs] = "-Xlinker"; 280 nargs += 1; 281 args[nargs] = "--undefined=__cfaabi_interpose_startup"; 282 nargs += 1; 279 283 280 284 } // if -
src/libcfa/bits/locks.h
rf792cb8 r7416d46a 9 9 // Author : Thierry Delisle 10 10 // Created On : Tue Oct 31 15:14:38 2017 11 // Last Modified By : --12 // Last Modified On : --13 // Update Count : 011 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Dec 8 16:02:22 2017 13 // Update Count : 1 14 14 // 15 15 … … 24 24 #elif defined( __i386 ) || defined( __x86_64 ) 25 25 #define Pause() __asm__ __volatile__ ( "pause" : : : ) 26 #elif defined( __ARM_ARCH ) 27 #define Pause() __asm__ __volatile__ ( "nop" : : : ) 26 28 #else 27 29 #error unsupported architecture 28 30 #endif 29 31 30 #if defined( __i386 ) || defined( __x86_64 ) 32 #if defined( __i386 ) || defined( __x86_64 ) || defined( __ARM_ARCH ) 31 33 // Intel recommendation 32 34 #define __ALIGN__ __attribute__(( aligned (128) )) … … 37 39 #endif 38 40 39 #if defined( __x86_64 )41 #if __SIZEOF_SIZE_T__ == 8 40 42 #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_8( &(lock), 1 ) == 0 41 43 #define __lock_release( lock ) __sync_lock_release_8( &(lock) ); 42 #elif defined( __i386 )44 #elif __SIZEOF_SIZE_T__ == 4 43 45 #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_4( &(lock), 1 ) == 0 44 46 #define __lock_release( lock ) __sync_lock_release_4( &(lock) ); … … 48 50 49 51 struct __spinlock_t { 50 __ALIGN__ volatile uintptr_t lock;52 __ALIGN__ volatile size_t lock; 51 53 #ifdef __CFA_DEBUG__ 52 54 const char * prev_name; … … 56 58 57 59 #ifdef __cforall 60 extern "C" { 61 extern void disable_interrupts(); 62 extern void enable_interrupts_noPoll(); 63 } 64 58 65 extern void yield( unsigned int ); 59 66 extern thread_local struct thread_desc * volatile this_thread; 67 extern thread_local struct processor * volatile this_processor; 60 68 61 69 static inline void ?{}( __spinlock_t & this ) { … … 66 74 static inline _Bool try_lock ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { 67 75 _Bool result = __lock_test_and_test_and_set( this.lock ); 68 __cfaabi_dbg_debug_do( 69 if( result ) { 76 if( result ) { 77 disable_interrupts(); 78 __cfaabi_dbg_debug_do( 70 79 this.prev_name = caller; 71 80 this.prev_thrd = this_thread; 72 }73 )81 ) 82 } 74 83 return result; 75 84 } … … 97 106 #endif 98 107 } 108 disable_interrupts(); 99 109 __cfaabi_dbg_debug_do( 100 110 this.prev_name = caller; … … 103 113 } 104 114 105 // Lock the spinlock, spin if already acquired 106 static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { 107 for ( unsigned int i = 1;; i += 1 ) { 108 if ( __lock_test_and_test_and_set( this.lock ) ) break; 109 yield( i ); 110 } 111 __cfaabi_dbg_debug_do( 112 this.prev_name = caller; 113 this.prev_thrd = this_thread; 114 ) 115 } 115 // // Lock the spinlock, yield if already acquired 116 // static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { 117 // for ( unsigned int i = 1;; i += 1 ) { 118 // if ( __lock_test_and_test_and_set( this.lock ) ) break; 119 // yield( i ); 120 // } 121 // disable_interrupts(); 122 // __cfaabi_dbg_debug_do( 123 // this.prev_name = caller; 124 // this.prev_thrd = this_thread; 125 // ) 126 // } 116 127 117 128 static inline void unlock( __spinlock_t & this ) { 129 enable_interrupts_noPoll(); 118 130 __lock_release( this.lock ); 119 131 } -
src/libcfa/concurrency/invoke.c
rf792cb8 r7416d46a 10 10 // Created On : Tue Jan 17 12:27:26 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Jul 21 22:28:33 201713 // Update Count : 112 // Last Modified On : Tue Jan 23 14:04:56 2018 13 // Update Count : 2 14 14 // 15 15 … … 133 133 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520 134 134 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F; //Vol. 1 8-7 135 136 #elif defined( __ARM_ARCH ) 137 138 struct FakeStack { 139 float fpRegs[16]; // floating point registers 140 void *intRegs[9]; // integer/pointer registers 141 void *arg[2]; // placeholder for this pointer 142 }; 143 144 ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack ); 145 ((struct machine_context_t *)stack->context)->FP = NULL; 146 147 struct FakeStack *fs = (struct FakeStack *)((struct machine_context_t *)stack->context)->SP; 148 149 fs->intRegs[8] = CtxInvokeStub; 150 fs->arg[0] = this; 151 fs->arg[1] = invoke; 135 152 #else 136 153 #error Only __i386__ and __x86_64__ is supported for threads in cfa -
src/libcfa/concurrency/invoke.h
rf792cb8 r7416d46a 10 10 // Created On : Tue Jan 17 12:27:26 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Jul 21 22:28:56 201713 // Update Count : 112 // Last Modified On : Tue Jan 23 14:55:46 2018 13 // Update Count : 3 14 14 // 15 15 … … 134 134 // instrusive link field for threads 135 135 struct thread_desc * next; 136 137 __cfaabi_dbg_debug_do( 138 // instrusive link field for debugging 139 struct thread_desc * dbg_next; 140 struct thread_desc * dbg_prev; 141 ) 136 142 }; 137 143 … … 203 209 "movl %%ebp,%1\n" \ 204 210 : "=rm" (ctx.SP), "=rm" (ctx.FP) ) 211 #elif defined( __ARM_ARCH ) 212 #define CtxGet( ctx ) __asm__ ( \ 213 "mov %0,%%sp\n" \ 214 "mov %1,%%r11\n" \ 215 : "=rm" (ctx.SP), "=rm" (ctx.FP) ) 205 216 #endif 206 217 -
src/libcfa/concurrency/kernel.c
rf792cb8 r7416d46a 10 10 // Created On : Tue Jan 17 12:27:26 2017 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Jul 21 22:33:18201713 // Update Count : 212 // Last Modified On : Fri Dec 8 16:23:33 2017 13 // Update Count : 3 14 14 // 15 15 16 16 //C Includes 17 17 #include <stddef.h> 18 #define ftype `ftype` 18 19 extern "C" { 19 20 #include <stdio.h> … … 23 24 #include <unistd.h> 24 25 } 26 #undef ftype 25 27 26 28 //CFA Includes … … 240 242 void finishRunning(processor * this) with( this->finish ) { 241 243 if( action_code == Release ) { 244 verify( disable_preempt_count > 1 ); 242 245 unlock( *lock ); 243 246 } … … 246 249 } 247 250 else if( action_code == Release_Schedule ) { 251 verify( disable_preempt_count > 1 ); 248 252 unlock( *lock ); 249 253 ScheduleThread( thrd ); 250 254 } 251 255 else if( action_code == Release_Multi ) { 256 verify( disable_preempt_count > lock_count ); 252 257 for(int i = 0; i < lock_count; i++) { 253 258 unlock( *locks[i] ); … … 363 368 this_processor->finish.lock = lock; 364 369 365 verify( disable_preempt_count > 0);370 verify( disable_preempt_count > 1 ); 366 371 suspend(); 367 372 verify( disable_preempt_count > 0 ); … … 389 394 this_processor->finish.thrd = thrd; 390 395 391 verify( disable_preempt_count > 0);396 verify( disable_preempt_count > 1 ); 392 397 suspend(); 393 398 verify( disable_preempt_count > 0 ); … … 514 519 } 515 520 521 //============================================================================================= 522 // Unexpected Terminating logic 523 //============================================================================================= 524 525 516 526 static __spinlock_t kernel_abort_lock; 517 527 static __spinlock_t kernel_debug_lock; … … 609 619 } 610 620 621 //----------------------------------------------------------------------------- 622 // Debug 623 __cfaabi_dbg_debug_do( 624 struct { 625 thread_desc * tail; 626 } __cfaabi_dbg_thread_list = { NULL }; 627 628 void __cfaabi_dbg_thread_register( thread_desc * thrd ) { 629 if( !__cfaabi_dbg_thread_list.tail ) { 630 __cfaabi_dbg_thread_list.tail = thrd; 631 return; 632 } 633 __cfaabi_dbg_thread_list.tail->dbg_next = thrd; 634 thrd->dbg_prev = __cfaabi_dbg_thread_list.tail; 635 __cfaabi_dbg_thread_list.tail = thrd; 636 } 637 638 void __cfaabi_dbg_thread_unregister( thread_desc * thrd ) { 639 thread_desc * prev = thrd->dbg_prev; 640 thread_desc * next = thrd->dbg_next; 641 642 if( next ) { next->dbg_prev = prev; } 643 else { 644 assert( __cfaabi_dbg_thread_list.tail == thrd ); 645 __cfaabi_dbg_thread_list.tail = prev; 646 } 647 648 if( prev ) { prev->dbg_next = next; } 649 650 thrd->dbg_prev = NULL; 651 thrd->dbg_next = NULL; 652 } 653 ) 611 654 // Local Variables: // 612 655 // mode: c // -
src/libcfa/concurrency/kernel_private.h
rf792cb8 r7416d46a 85 85 extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst); 86 86 87 __cfaabi_dbg_debug_do( 88 extern void __cfaabi_dbg_thread_register ( thread_desc * thrd ); 89 extern void __cfaabi_dbg_thread_unregister( thread_desc * thrd ); 90 ) 91 87 92 //----------------------------------------------------------------------------- 88 93 // Utils -
src/libcfa/concurrency/monitor.c
rf792cb8 r7416d46a 53 53 static inline __lock_size_t aggregate ( monitor_desc * storage [], const __waitfor_mask_t & mask ); 54 54 55 #ifndef __CFA_LOCK_NO_YIELD56 #define DO_LOCK lock_yield57 #else58 #define DO_LOCK lock59 #endif60 61 55 //----------------------------------------------------------------------------- 62 56 // Useful defines … … 90 84 static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) { 91 85 // Lock the monitor spinlock 92 DO_LOCK( this->lock __cfaabi_dbg_ctx2 );86 lock( this->lock __cfaabi_dbg_ctx2 ); 93 87 thread_desc * thrd = this_thread; 88 89 verify( disable_preempt_count > 0 ); 94 90 95 91 __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner); … … 121 117 // Some one else has the monitor, wait in line for it 122 118 append( this->entry_queue, thrd ); 119 120 verify( disable_preempt_count > 0 ); 121 123 122 BlockInternal( &this->lock ); 124 123 … … 138 137 static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) { 139 138 // Lock the monitor spinlock 140 DO_LOCK( this->lock __cfaabi_dbg_ctx2 );139 lock( this->lock __cfaabi_dbg_ctx2 ); 141 140 thread_desc * thrd = this_thread; 142 141 … … 201 200 // Leave single monitor 202 201 void __leave_monitor_desc( monitor_desc * this ) { 203 // Lock the monitor spinlock , DO_LOCK to reduce contention204 DO_LOCK( this->lock __cfaabi_dbg_ctx2 );202 // Lock the monitor spinlock 203 lock( this->lock __cfaabi_dbg_ctx2 ); 205 204 206 205 __cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner); … … 248 247 249 248 // Lock the monitor now 250 DO_LOCK( this->lock __cfaabi_dbg_ctx2 );249 lock( this->lock __cfaabi_dbg_ctx2 ); 251 250 252 251 disable_interrupts(); … … 397 396 append( this.blocked, &waiter ); 398 397 398 verify( disable_preempt_count == 0 ); 399 399 400 // Lock all monitors (aggregates the locks as well) 400 401 lock_all( monitors, locks, count ); 402 403 // verifyf( disable_preempt_count == count, "Got %d, expected %d\n", disable_preempt_count, count ); 404 if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); } 401 405 402 406 // Find the next thread(s) to run … … 473 477 monitor_ctx( this.monitors, this.monitor_count ); 474 478 479 verify( disable_preempt_count == 0 ); 480 475 481 // Lock all monitors (aggregates the locks them as well) 476 482 lock_all( monitors, locks, count ); 483 484 // verify( disable_preempt_count == count ); 485 if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); } 486 477 487 478 488 // Create the node specific to this wait operation … … 737 747 static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) { 738 748 for( __lock_size_t i = 0; i < count; i++ ) { 739 DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 );749 lock( *locks[i] __cfaabi_dbg_ctx2 ); 740 750 } 741 751 } … … 744 754 for( __lock_size_t i = 0; i < count; i++ ) { 745 755 __spinlock_t * l = &source[i]->lock; 746 DO_LOCK( *l __cfaabi_dbg_ctx2 );756 lock( *l __cfaabi_dbg_ctx2 ); 747 757 if(locks) locks[i] = l; 748 758 } -
src/libcfa/concurrency/preemption.c
rf792cb8 r7416d46a 10 10 // Created On : Mon Jun 5 14:20:42 2017 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Jul 21 22:36:05 201713 // Update Count : 212 // Last Modified On : Tue Jan 23 17:59:30 2018 13 // Update Count : 7 14 14 // 15 15 16 16 #include "preemption.h" 17 17 18 #define ftype `ftype` 18 19 extern "C" { 19 20 #include <errno.h> 20 #include <execinfo.h>21 #define __USE_GNU22 #include <signal.h>23 #undef __USE_GNU24 21 #include <stdio.h> 25 22 #include <string.h> 26 23 #include <unistd.h> 27 24 } 28 29 30 #ifdef __USE_STREAM__ 31 #include "fstream" 32 #endif 25 #undef ftype 26 27 #include "bits/signal.h" 33 28 34 29 //TODO move to defaults … … 39 34 return __CFA_DEFAULT_PREEMPTION__; 40 35 } 41 42 // Short hands for signal context information43 #define __CFA_SIGCXT__ ucontext_t *44 #define __CFA_SIGPARMS__ __attribute__((unused)) int sig, __attribute__((unused)) siginfo_t *sfp, __attribute__((unused)) __CFA_SIGCXT__ cxt45 36 46 37 // FwdDeclarations : timeout handlers … … 53 44 void sigHandler_abort ( __CFA_SIGPARMS__ ); 54 45 55 // FwdDeclarations : sigaction wrapper56 static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags );57 58 46 // FwdDeclarations : alarm thread main 59 47 void * alarm_loop( __attribute__((unused)) void * args ); 60 48 61 49 // Machine specific register name 62 #if def __x86_64__50 #if defined(__x86_64__) 63 51 #define CFA_REG_IP REG_RIP 64 #el se52 #elif defined(__i386__) 65 53 #define CFA_REG_IP REG_EIP 54 #elif defined(__ARM_ARCH__) 55 #define CFA_REG_IP REG_R15 66 56 #endif 67 57 … … 179 169 void enable_interrupts_noPoll() { 180 170 __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST ); 181 verify ( prev != 0u); // If this triggers someone is enabled already enabled interrupts171 verifyf( prev != 0u, "Incremented from %u\n", prev ); // If this triggers someone is enabled already enabled interrupts 182 172 } 183 173 } … … 243 233 // Setup proper signal handlers 244 234 __kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // CtxSwitch handler 245 // __kernel_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO ); // Failure handler246 // __kernel_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO ); // Failure handler247 235 248 236 signal_block( SIGALRM ); … … 296 284 // Receives SIGUSR1 signal and causes the current thread to yield 297 285 void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) { 286 #if defined( __ARM_ARCH ) 287 __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.arm_pc); ) 288 #else 298 289 __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); ) 299 300 // Check if it is safe to preempt here 290 #endif 291 292 // Check if it is safe to preempt here 301 293 if( !preemption_ready() ) { return; } 294 295 __cfaabi_dbg_print_buffer_decl(" KERNEL: preempting core %p (%p).\n", this_processor, this_thread); 302 296 303 297 preemption_in_progress = true; // Sync flag : prevent recursive calls to the signal handler … … 371 365 } 372 366 373 // Sigaction wrapper : register an signal handler374 static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ) {375 struct sigaction act;376 377 act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;378 act.sa_flags = flags;379 380 if ( sigaction( sig, &act, NULL ) == -1 ) {381 __cfaabi_dbg_print_buffer_decl(382 " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",383 sig, handler, flags, errno, strerror( errno )384 );385 _exit( EXIT_FAILURE );386 }387 }388 389 // Sigaction wrapper : restore default handler390 static void __kernel_sigdefault( int sig ) {391 struct sigaction act;392 393 act.sa_handler = SIG_DFL;394 act.sa_flags = 0;395 sigemptyset( &act.sa_mask );396 397 if ( sigaction( sig, &act, NULL ) == -1 ) {398 __cfaabi_dbg_print_buffer_decl(399 " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",400 sig, errno, strerror( errno )401 );402 _exit( EXIT_FAILURE );403 }404 }405 406 //=============================================================================================407 // Terminating Signals logic408 //=============================================================================================409 410 __cfaabi_dbg_debug_do(411 static void __kernel_backtrace( int start ) {412 // skip first N stack frames413 414 enum { Frames = 50 };415 void * array[Frames];416 int size = backtrace( array, Frames );417 char ** messages = backtrace_symbols( array, size );418 419 // find executable name420 *index( messages[0], '(' ) = '\0';421 #ifdef __USE_STREAM__422 serr | "Stack back trace for:" | messages[0] | endl;423 #else424 fprintf( stderr, "Stack back trace for: %s\n", messages[0]);425 #endif426 427 // skip last 2 stack frames after main428 for ( int i = start; i < size && messages != NULL; i += 1 ) {429 char * name = NULL;430 char * offset_begin = NULL;431 char * offset_end = NULL;432 433 for ( char *p = messages[i]; *p; ++p ) {434 // find parantheses and +offset435 if ( *p == '(' ) {436 name = p;437 }438 else if ( *p == '+' ) {439 offset_begin = p;440 }441 else if ( *p == ')' ) {442 offset_end = p;443 break;444 }445 }446 447 // if line contains symbol print it448 int frameNo = i - start;449 if ( name && offset_begin && offset_end && name < offset_begin ) {450 // delimit strings451 *name++ = '\0';452 *offset_begin++ = '\0';453 *offset_end++ = '\0';454 455 #ifdef __USE_STREAM__456 serr | "(" | frameNo | ")" | messages[i] | ":"457 | name | "+" | offset_begin | offset_end | endl;458 #else459 fprintf( stderr, "(%i) %s : %s + %s %s\n", frameNo, messages[i], name, offset_begin, offset_end);460 #endif461 }462 // otherwise, print the whole line463 else {464 #ifdef __USE_STREAM__465 serr | "(" | frameNo | ")" | messages[i] | endl;466 #else467 fprintf( stderr, "(%i) %s\n", frameNo, messages[i] );468 #endif469 }470 }471 472 free( messages );473 }474 )475 476 // void sigHandler_segv( __CFA_SIGPARMS__ ) {477 // __cfaabi_dbg_debug_do(478 // #ifdef __USE_STREAM__479 // serr | "*CFA runtime error* program cfa-cpp terminated with"480 // | (sig == SIGSEGV ? "segment fault." : "bus error.")481 // | endl;482 // #else483 // fprintf( stderr, "*CFA runtime error* program cfa-cpp terminated with %s\n", sig == SIGSEGV ? "segment fault." : "bus error." );484 // #endif485 486 // // skip first 2 stack frames487 // __kernel_backtrace( 1 );488 // )489 // exit( EXIT_FAILURE );490 // }491 492 // void sigHandler_abort( __CFA_SIGPARMS__ ) {493 // // skip first 6 stack frames494 // __cfaabi_dbg_debug_do( __kernel_backtrace( 6 ); )495 496 // // reset default signal handler497 // __kernel_sigdefault( SIGABRT );498 499 // raise( SIGABRT );500 // }501 502 367 // Local Variables: // 503 368 // mode: c // -
src/libcfa/concurrency/thread.c
rf792cb8 r7416d46a 38 38 self_mon_p = &self_mon; 39 39 next = NULL; 40 __cfaabi_dbg_debug_do( 41 dbg_next = NULL; 42 dbg_prev = NULL; 43 __cfaabi_dbg_thread_register(&this); 44 ) 40 45 41 46 monitors{ &self_mon_p, 1, (fptr_t)0 }; -
src/libcfa/interpose.c
rf792cb8 r7416d46a 22 22 #include <dlfcn.h> 23 23 #include <unistd.h> 24 #define __USE_GNU 25 #include <signal.h> 26 #undef __USE_GNU 27 #include <execinfo.h> 24 28 } 25 29 26 30 #include "bits/debug.h" 27 31 #include "bits/defs.h" 32 #include "bits/signal.h" 28 33 #include "startup.h" 29 34 30 void interpose_startup(void) __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));35 void __cfaabi_interpose_startup(void) __attribute__(( constructor( STARTUP_PRIORITY_CORE ) )); 31 36 32 37 typedef void (*generic_fptr_t)(void); … … 84 89 #define INIT_REALRTN( x, ver ) assign_ptr( (void**)&libc_##x, #x, ver) 85 90 86 void interpose_startup() { 91 void sigHandler_segv ( __CFA_SIGPARMS__ ); 92 void sigHandler_abort( __CFA_SIGPARMS__ ); 93 94 void __cfaabi_interpose_startup() { 87 95 const char *version = NULL; 88 96 89 97 INIT_REALRTN( abort, version ); 90 98 INIT_REALRTN( exit, version ); 91 } 99 100 __kernel_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO ); // Failure handler 101 __kernel_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO ); // Failure handler 102 __kernel_sigaction( SIGABRT, sigHandler_abort, SA_SIGINFO ); // Failure handler 103 } 104 105 //============================================================================================= 106 // Terminating Signals logic 107 //============================================================================================= 92 108 93 109 extern "C" { … … 137 153 libc_abort(); 138 154 } 155 } 156 157 // skip first 6 stack frames by default 158 static void __kernel_backtrace() { 159 // skip first N stack frames 160 int start = 6; 161 162 enum { Frames = 50 }; 163 void * array[Frames]; 164 int size = backtrace( array, Frames ); 165 char ** messages = backtrace_symbols( array, size ); 166 167 // find executable name 168 *index( messages[0], '(' ) = '\0'; 169 __cfaabi_dbg_bits_print_nolock( "Stack back trace for: %s\n", messages[0]); 170 171 // skip last 2 stack frames after main 172 for ( int i = start; i < size && messages != NULL; i += 1 ) { 173 char * name = NULL; 174 char * offset_begin = NULL; 175 char * offset_end = NULL; 176 177 for ( char *p = messages[i]; *p; ++p ) { 178 // find parantheses and +offset 179 if ( *p == '(' ) { 180 name = p; 181 } 182 else if ( *p == '+' ) { 183 offset_begin = p; 184 } 185 else if ( *p == ')' ) { 186 offset_end = p; 187 break; 188 } 189 } 190 191 // if line contains symbol print it 192 int frameNo = i - start; 193 if ( name && offset_begin && offset_end && name < offset_begin ) { 194 // delimit strings 195 *name++ = '\0'; 196 *offset_begin++ = '\0'; 197 *offset_end++ = '\0'; 198 199 __cfaabi_dbg_bits_print_nolock( "(%i) %s : %s + %s %s\n", frameNo, messages[i], name, offset_begin, offset_end); 200 } 201 // otherwise, print the whole line 202 else { 203 __cfaabi_dbg_bits_print_nolock( "(%i) %s\n", frameNo, messages[i] ); 204 } 205 } 206 207 free( messages ); 208 } 209 210 void sigHandler_segv( __CFA_SIGPARMS__ ) { 211 // skip first only 1 stack frames in case of segfault. 212 abortf( "*CFA runtime error* program cfa-cpp terminated with %s\n", sig == SIGSEGV ? "segment fault." : "bus error." ); 213 } 214 215 void sigHandler_abort( __CFA_SIGPARMS__ ) { 216 __kernel_backtrace(); 217 218 // reset default signal handler 219 __kernel_sigdefault( SIGABRT ); 220 221 raise( SIGABRT ); 139 222 } 140 223 -
src/libcfa/iostream
rf792cb8 r7416d46a 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Thu Dec 21 13:55:41 201713 // Update Count : 14 512 // Last Modified On : Thu Jan 25 13:08:39 2018 13 // Update Count : 149 14 14 // 15 15 … … 124 124 }; // readable 125 125 126 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, _Bool & ); 127 126 128 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, char & ); 127 129 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, signed char & ); … … 145 147 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long double _Complex & ); 146 148 149 // manipulators 150 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, istype & (*)( istype & ) ); 151 forall( dtype istype | istream( istype ) ) istype & endl( istype & is ); 152 147 153 struct _Istream_cstrUC { char * s; }; 148 154 _Istream_cstrUC cstr( char * ); -
src/libcfa/iostream.c
rf792cb8 r7416d46a 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Thu Dec 21 13:55:09 201713 // Update Count : 4 2712 // Last Modified On : Thu Jan 25 13:09:28 2018 13 // Update Count : 467 14 14 // 15 15 … … 19 19 #include <stdio.h> 20 20 #include <stdbool.h> // true/false 21 #include <string.h> // strlen 21 //#include <string.h> // strlen, strcmp 22 extern int strcmp (const char *__s1, const char *__s2) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); 23 extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); 22 24 #include <float.h> // DBL_DIG, LDBL_DIG 23 25 #include <complex.h> // creal, cimag … … 301 303 302 304 forall( dtype istype | istream( istype ) ) 305 istype & ?|?( istype & is, _Bool & b ) { 306 char val[6]; 307 fmt( is, "%5s", val ); 308 if ( strcmp( val, "true" ) == 0 ) b = true; 309 else if ( strcmp( val, "false" ) == 0 ) b = false; 310 else { 311 fprintf( stderr, "invalid _Bool constant\n" ); 312 abort(); 313 } // if 314 return is; 315 } // ?|? 316 317 forall( dtype istype | istream( istype ) ) 303 318 istype & ?|?( istype & is, char & c ) { 304 319 fmt( is, "%c", &c ); // must pass pointer through varg to fmt … … 410 425 } // ?|? 411 426 427 forall( dtype istype | istream( istype ) ) 428 istype & ?|?( istype & is, istype & (* manip)( istype & ) ) { 429 return manip( is ); 430 } // ?|? 431 432 forall( dtype istype | istream( istype ) ) 433 istype & endl( istype & is ) { 434 fmt( is, "%*[ \t\f\n\r\v]" ); // ignore whitespace 435 return is; 436 } // endl 437 412 438 _Istream_cstrUC cstr( char * str ) { return (_Istream_cstrUC){ str }; } 413 439 forall( dtype istype | istream( istype ) ) -
src/libcfa/stdlib.c
rf792cb8 r7416d46a 5 5 // file "LICENCE" distributed with Cforall. 6 6 // 7 // algorithm.c --7 // stdlib.c -- 8 8 // 9 9 // Author : Peter A. Buhr 10 10 // Created On : Thu Jan 28 17:10:29 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jan 2 12:20:32201813 // Update Count : 44 112 // Last Modified On : Wed Jan 3 08:29:29 2018 13 // Update Count : 444 14 14 // 15 15 … … 24 24 #include <complex.h> // _Complex_I 25 25 #include <assert.h> 26 27 //--------------------------------------- 26 28 27 29 // resize, non-array types … … 257 259 //--------------------------------------- 258 260 259 extern "C" { void srandom( unsigned int seed ) { srand48( seed ); } } // override C version261 extern "C" { void srandom( unsigned int seed ) { srand48( (long int)seed ); } } // override C version 260 262 char random( void ) { return (unsigned long int)random(); } 261 263 char random( char u ) { return random( (unsigned long int)u ); } -
src/prelude/prelude.cf
rf792cb8 r7416d46a 39 39 // ------------------------------------------------------------ 40 40 41 _Bool ?++( _Bool & ), ?++( volatile _Bool & );42 _Bool ?--( _Bool & ), ?--( volatile _Bool & );43 41 signed short ?++( signed short & ), ?++( volatile signed short & ); 44 42 signed short ?--( signed short & ), ?--( volatile signed short & ); … … 94 92 // ------------------------------------------------------------ 95 93 96 _Bool ++?( _Bool & ), --?( _Bool & );97 94 signed short ++?( signed short & ), --?( signed short & ); 98 95 signed int ++?( signed int & ), --?( signed int & ); … … 125 122 forall( ftype FT ) FT & *?( FT * ); 126 123 127 _Bool +?( _Bool ), -?( _Bool ) , ~?( _Bool );124 _Bool +?( _Bool ), -?( _Bool ); 128 125 signed int +?( signed int ), -?( signed int ), ~?( signed int ); 129 126 unsigned int +?( unsigned int ), -?( unsigned int ), ~?( unsigned int ); … … 157 154 // ------------------------------------------------------------ 158 155 159 _Bool ?*?( _Bool, _Bool ), ?/?( _Bool, _Bool ), ?%?( _Bool, _Bool );160 156 signed int ?*?( signed int, signed int ), ?/?( signed int, signed int ), ?%?( signed int, signed int ); 161 157 unsigned int ?*?( unsigned int, unsigned int ), ?/?( unsigned int, unsigned int ), ?%?( unsigned int, unsigned int ); … … 215 211 // ------------------------------------------------------------ 216 212 217 _Bool ?<<?( _Bool, _Bool ), ?>>?( _Bool, _Bool );218 213 signed int ?<<?( signed int, signed int ), ?>>?( signed int, signed int ); 219 214 unsigned int ?<<?( unsigned int, unsigned int ), ?>>?( unsigned int, unsigned int ); … … 467 462 468 463 469 _Bool ?*=?( _Bool &, _Bool ), ?*=?( volatile _Bool &, _Bool );470 464 char ?*=?( char &, char ), ?*=?( volatile char &, char ); 471 465 char signed ?*=?( char signed &, char signed ), ?*=?( volatile char signed &, char signed ); … … 534 528 unsigned long long int ?-=?( unsigned long long int &, unsigned long long int ), ?-=?( volatile unsigned long long int &, unsigned long long int ); 535 529 536 _Bool ?<<=?( _Bool &, _Bool ), ?<<=?( volatile _Bool &, _Bool );537 530 char ?<<=?( char &, char ), ?<<=?( volatile char &, char ); 538 531 char signed ?<<=?( char signed &, char signed ), ?<<=?( volatile char signed &, char signed ); … … 547 540 unsigned long long int ?<<=?( unsigned long long int &, unsigned long long int ), ?<<=?( volatile unsigned long long int &, unsigned long long int ); 548 541 549 _Bool ?>>=?( _Bool &, _Bool ), ?>>=?( volatile _Bool &, _Bool );550 542 char ?>>=?( char &, char ), ?>>=?( volatile char &, char ); 551 543 char signed ?>>=?( char signed &, char signed ), ?>>=?( volatile char signed &, char signed ); -
src/tests/.expect/alloc-ERROR.txt
rf792cb8 r7416d46a 1 1 alloc.c:264:1 error: No reasonable alternatives for expression Applying untyped: 2 Name: ?=? 3 ...to: 4 Name: p 5 Applying untyped: 6 Name: realloc 7 ...to: 8 Name: stp 9 Applying untyped: 10 Name: ?*? 11 ...to: 12 Name: dim 13 Sizeof Expression on: Applying untyped: 14 Name: *? 15 ...to: 16 Name: stp 17 18 19 20 21 alloc.c:265:1 error: No reasonable alternatives for expression Applying untyped: 2 22 Name: ?=? 3 23 ...to: … … 19 39 20 40 21 alloc.c:26 5:1 error: No reasonable alternatives for expression Applying untyped:41 alloc.c:266:1 error: No reasonable alternatives for expression Applying untyped: 22 42 Name: ?=? 23 43 ...to: … … 30 50 31 51 32 alloc.c:26 6:1 error: No reasonable alternatives for expression Applying untyped:52 alloc.c:267:1 error: No reasonable alternatives for expression Applying untyped: 33 53 Name: ?=? 34 54 ...to: -
src/tests/.expect/alloc.txt
rf792cb8 r7416d46a 60 60 pointer arithmetic 0 61 61 CFA deep malloc 0xdeadbeef 62 63 SHOULD FAIL -
src/tests/.expect/io.txt
rf792cb8 r7416d46a 27 27 28 28 output basic types 29 false 29 30 A 23 93 30 31 1 2 3 4 5 6 7 8 -
src/tests/.expect/literals.x64.txt
rf792cb8 r7416d46a 35 35 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); 36 36 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); 37 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); 38 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); 39 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); 40 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); 41 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); 42 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); 43 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); 44 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); 45 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); 46 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); 47 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); 48 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); 49 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); 50 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); 51 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); 52 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); 53 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); 37 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); 38 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); 39 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); 40 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); 41 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); 42 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); 43 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); 44 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); 45 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); 46 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); 47 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); 48 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); 49 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); 50 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); 51 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); 52 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); 53 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); 54 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); 55 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)); 56 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); 54 57 struct _Istream_cstrUC { 55 58 char *__s__Pc_1; … … 78 81 ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=__s__Pc_1) /* ?{} */); 79 82 } 80 struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object13 00);81 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_object13 01), __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);83 struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1329); 84 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); 82 85 struct _Istream_cstrC { 83 86 char *__s__Pc_1; … … 117 120 ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=__size__i_1) /* ?{} */); 118 121 } 119 struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object13 11, signed int __size__i_1);120 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_object13 12), __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);122 struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1340, signed int __size__i_1); 123 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); 121 124 enum __anonymous0 { 122 125 __sepSize__C13e__anonymous0_1 = 16, … … 398 401 399 402 } 400 _Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object13 22);401 void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object13 23);402 void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object13 24, _Bool __anonymous_object1325);403 const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object13 26);404 void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object13 27, const char *__anonymous_object1328);405 _Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object13 29);406 void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object13 30, _Bool __anonymous_object1331);407 void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object13 32);408 void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object13 33);409 _Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object13 34);410 _Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object13 35);411 const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object13 36);412 void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object13 37, const char *__anonymous_object1338);413 const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object13 39);414 void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object13 40, const char *__anonymous_object1341);415 signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object13 42);416 signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object13 43);417 void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object13 44, const char *__name__PCc_1, const char *__mode__PCc_1);418 void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object13 45, const char *__name__PCc_1);419 void __close__F_R9sofstream__1(struct ofstream *__anonymous_object13 46);420 struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object13 47, const char *__data__PCc_1, unsigned long int __size__Ul_1);421 signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object13 48, const char *__fmt__PCc_1, ...);403 _Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1351); 404 void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1352); 405 void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1353, _Bool __anonymous_object1354); 406 const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1355); 407 void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1356, const char *__anonymous_object1357); 408 _Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1358); 409 void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1359, _Bool __anonymous_object1360); 410 void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1361); 411 void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1362); 412 _Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1363); 413 _Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1364); 414 const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1365); 415 void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1366, const char *__anonymous_object1367); 416 const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1368); 417 void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1369, const char *__anonymous_object1370); 418 signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1371); 419 signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1372); 420 void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1373, const char *__name__PCc_1, const char *__mode__PCc_1); 421 void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1374, const char *__name__PCc_1); 422 void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1375); 423 struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1376, const char *__data__PCc_1, unsigned long int __size__Ul_1); 424 signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1377, const char *__fmt__PCc_1, ...); 422 425 void ___constructor__F_R9sofstream__1(struct ofstream *__os__R9sofstream_1); 423 426 void ___constructor__F_R9sofstreamPCcPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1); … … 458 461 struct ifstream *__read__FR9sifstream_R9sifstreamPcUl__1(struct ifstream *__is__R9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1); 459 462 struct ifstream *__ungetc__FR9sifstream_R9sifstreamc__1(struct ifstream *__is__R9sifstream_1, char __c__c_1); 460 signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object13 49, const char *__fmt__PCc_1, ...);463 signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1378, const char *__fmt__PCc_1, ...); 461 464 void ___constructor__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1); 462 465 void ___constructor__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1); … … 468 471 struct ofstream *_tmp_cp_ret2; 469 472 __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){ 470 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_object13 50))__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));471 } 472 ((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_object1 376))__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));473 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)); 474 } 475 ((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)); 473 476 } 474 477 void __f__F_Sc__1(signed char __v__Sc_1){ … … 477 480 struct ofstream *_tmp_cp_ret5; 478 481 __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){ 479 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_object14 55))__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));480 } 481 ((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_object1 481))__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));482 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)); 483 } 484 ((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)); 482 485 } 483 486 void __f__F_Uc__1(unsigned char __v__Uc_1){ … … 486 489 struct ofstream *_tmp_cp_ret8; 487 490 __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){ 488 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_object15 60))__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));489 } 490 ((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_object1 586))__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));491 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)); 492 } 493 ((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)); 491 494 } 492 495 void __f__F_s__1(signed short int __v__s_1){ … … 495 498 struct ofstream *_tmp_cp_ret11; 496 499 __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){ 497 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_object16 65))__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));498 } 499 ((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_object1 691))__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));500 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)); 501 } 502 ((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)); 500 503 } 501 504 void __f__F_Us__1(unsigned short int __v__Us_1){ … … 504 507 struct ofstream *_tmp_cp_ret14; 505 508 __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){ 506 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_object17 70))__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));507 } 508 ((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_object1 796))__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));509 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)); 510 } 511 ((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)); 509 512 } 510 513 void __f__F_Ul__1(unsigned long int __v__Ul_1){ … … 513 516 struct ofstream *_tmp_cp_ret17; 514 517 __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){ 515 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_object1 875))__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));516 } 517 ((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_object19 01))__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));518 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)); 519 } 520 ((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)); 518 521 } 519 522 signed int __main__Fi___1(){ -
src/tests/.expect/literals.x86.txt
rf792cb8 r7416d46a 35 35 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); 36 36 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); 37 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); 38 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); 39 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); 40 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); 41 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); 42 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); 43 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); 44 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); 45 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); 46 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); 47 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); 48 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); 49 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); 50 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); 51 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); 52 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); 53 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); 37 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); 38 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); 39 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); 40 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); 41 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); 42 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); 43 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); 44 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); 45 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); 46 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); 47 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); 48 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); 49 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); 50 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); 51 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); 52 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); 53 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); 54 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); 55 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)); 56 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); 54 57 struct _Istream_cstrUC { 55 58 char *__s__Pc_1; … … 78 81 ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=__s__Pc_1) /* ?{} */); 79 82 } 80 struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object13 00);81 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_object13 01), __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);83 struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1329); 84 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); 82 85 struct _Istream_cstrC { 83 86 char *__s__Pc_1; … … 117 120 ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=__size__i_1) /* ?{} */); 118 121 } 119 struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object13 11, signed int __size__i_1);120 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_object13 12), __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);122 struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1340, signed int __size__i_1); 123 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); 121 124 enum __anonymous0 { 122 125 __sepSize__C13e__anonymous0_1 = 16, … … 398 401 399 402 } 400 _Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object13 22);401 void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object13 23);402 void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object13 24, _Bool __anonymous_object1325);403 const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object13 26);404 void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object13 27, const char *__anonymous_object1328);405 _Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object13 29);406 void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object13 30, _Bool __anonymous_object1331);407 void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object13 32);408 void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object13 33);409 _Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object13 34);410 _Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object13 35);411 const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object13 36);412 void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object13 37, const char *__anonymous_object1338);413 const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object13 39);414 void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object13 40, const char *__anonymous_object1341);415 signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object13 42);416 signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object13 43);417 void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object13 44, const char *__name__PCc_1, const char *__mode__PCc_1);418 void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object13 45, const char *__name__PCc_1);419 void __close__F_R9sofstream__1(struct ofstream *__anonymous_object13 46);420 struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object13 47, const char *__data__PCc_1, unsigned long int __size__Ul_1);421 signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object13 48, const char *__fmt__PCc_1, ...);403 _Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1351); 404 void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1352); 405 void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1353, _Bool __anonymous_object1354); 406 const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1355); 407 void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1356, const char *__anonymous_object1357); 408 _Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1358); 409 void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1359, _Bool __anonymous_object1360); 410 void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1361); 411 void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1362); 412 _Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1363); 413 _Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1364); 414 const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1365); 415 void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1366, const char *__anonymous_object1367); 416 const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1368); 417 void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1369, const char *__anonymous_object1370); 418 signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1371); 419 signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1372); 420 void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1373, const char *__name__PCc_1, const char *__mode__PCc_1); 421 void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1374, const char *__name__PCc_1); 422 void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1375); 423 struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1376, const char *__data__PCc_1, unsigned long int __size__Ul_1); 424 signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1377, const char *__fmt__PCc_1, ...); 422 425 void ___constructor__F_R9sofstream__1(struct ofstream *__os__R9sofstream_1); 423 426 void ___constructor__F_R9sofstreamPCcPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1); … … 458 461 struct ifstream *__read__FR9sifstream_R9sifstreamPcUl__1(struct ifstream *__is__R9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1); 459 462 struct ifstream *__ungetc__FR9sifstream_R9sifstreamc__1(struct ifstream *__is__R9sifstream_1, char __c__c_1); 460 signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object13 49, const char *__fmt__PCc_1, ...);463 signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1378, const char *__fmt__PCc_1, ...); 461 464 void ___constructor__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1); 462 465 void ___constructor__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1); … … 468 471 struct ofstream *_tmp_cp_ret2; 469 472 __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){ 470 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_object13 50))__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));471 } 472 ((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_object1 376))__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));473 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)); 474 } 475 ((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)); 473 476 } 474 477 void __f__F_Sc__1(signed char __v__Sc_1){ … … 477 480 struct ofstream *_tmp_cp_ret5; 478 481 __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){ 479 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_object14 55))__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));480 } 481 ((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_object1 481))__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));482 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)); 483 } 484 ((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)); 482 485 } 483 486 void __f__F_Uc__1(unsigned char __v__Uc_1){ … … 486 489 struct ofstream *_tmp_cp_ret8; 487 490 __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){ 488 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_object15 60))__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));489 } 490 ((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_object1 586))__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));491 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)); 492 } 493 ((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)); 491 494 } 492 495 void __f__F_s__1(signed short int __v__s_1){ … … 495 498 struct ofstream *_tmp_cp_ret11; 496 499 __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){ 497 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_object16 65))__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));498 } 499 ((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_object1 691))__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));500 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)); 501 } 502 ((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)); 500 503 } 501 504 void __f__F_Us__1(unsigned short int __v__Us_1){ … … 504 507 struct ofstream *_tmp_cp_ret14; 505 508 __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){ 506 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_object17 70))__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));507 } 508 ((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_object1 796))__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));509 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)); 510 } 511 ((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)); 509 512 } 510 513 void __f__F_Ui__1(unsigned int __v__Ui_1){ … … 513 516 struct ofstream *_tmp_cp_ret17; 514 517 __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){ 515 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_object1 875))__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));516 } 517 ((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_object19 01))__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));518 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)); 519 } 520 ((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)); 518 521 } 519 522 signed int __main__Fi___1(){ -
src/tests/.expect/sum.txt
rf792cb8 r7416d46a 4 4 sum from 0.5 to 1.5 is 9.5, check 9.5 5 5 sum from 5 to 15 is 95 95, check 95 95 6 sum from 5 to 15 is 95, check 95 -
src/tests/Makefile.am
rf792cb8 r7416d46a 17 17 debug=yes 18 18 19 quick_test= vector_testavl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes19 quick_test=avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes 20 20 21 21 if BUILD_CONCURRENCY … … 44 44 45 45 .PHONY : list 46 EXTRA_PROGRAMS = fstream_test vector_testavl_test # build but do not install46 EXTRA_PROGRAMS = fstream_test avl_test # build but do not install 47 47 48 48 fstream_test_SOURCES = fstream_test.c 49 49 fstream_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS} 50 51 vector_test_SOURCES = vector/vector_int.c vector/array.c vector/vector_test.c52 vector_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}53 50 54 51 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 73 % : %.c @CFA_BINDIR@/@CFA_NAME@ 77 74 ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@} 78 79 dtor-early-exit-ERR1: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@80 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}81 82 dtor-early-exit-ERR2: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@83 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}84 75 85 76 declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@ … … 110 101 ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@} 111 102 112 memberCtors-ERR1: memberCtors.c @CFA_BINDIR@/@CFA_NAME@113 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}114 115 ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@116 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}117 118 103 completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@ 119 104 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} … … 124 109 alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@ 125 110 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} 111 112 # Constructor/destructor tests 113 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ 114 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} 115 116 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ 117 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@} 118 119 raii/memberCtors-ERR1: raii/memberCtors.c @CFA_BINDIR@/@CFA_NAME@ 120 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} 121 122 raii/ctor-autogen-ERR1: raii/ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@ 123 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} 124 -
src/tests/Makefile.in
rf792cb8 r7416d46a 94 94 @BUILD_DEBUG_TRUE@@BUILD_RELEASE_FALSE@am__append_2 = -debug 95 95 @BUILD_DEBUG_TRUE@@BUILD_RELEASE_TRUE@am__append_3 = ${DEBUG_FLAGS} 96 EXTRA_PROGRAMS = fstream_test$(EXEEXT) vector_test$(EXEEXT) \ 97 avl_test$(EXEEXT) 96 EXTRA_PROGRAMS = fstream_test$(EXEEXT) avl_test$(EXEEXT) 98 97 subdir = src/tests 99 98 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 … … 122 121 fstream_test_LDADD = $(LDADD) 123 122 fstream_test_LINK = $(CCLD) $(fstream_test_CFLAGS) $(CFLAGS) \ 124 $(AM_LDFLAGS) $(LDFLAGS) -o $@125 am_vector_test_OBJECTS = vector/vector_test-vector_int.$(OBJEXT) \126 vector/vector_test-array.$(OBJEXT) \127 vector/vector_test-vector_test.$(OBJEXT)128 vector_test_OBJECTS = $(am_vector_test_OBJECTS)129 vector_test_LDADD = $(LDADD)130 vector_test_LINK = $(CCLD) $(vector_test_CFLAGS) $(CFLAGS) \131 123 $(AM_LDFLAGS) $(LDFLAGS) -o $@ 132 124 AM_V_P = $(am__v_P_@AM_V@) … … 162 154 am__v_CCLD_0 = @echo " CCLD " $@; 163 155 am__v_CCLD_1 = 164 SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) \ 165 $(vector_test_SOURCES) 166 DIST_SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) \ 167 $(vector_test_SOURCES) 156 SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) 157 DIST_SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) 168 158 am__can_run_installinfo = \ 169 159 case $$AM_UPDATE_INFO_DIR in \ … … 313 303 top_srcdir = @top_srcdir@ 314 304 debug = yes 315 quick_test = vector_testavl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes305 quick_test = avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes 316 306 @BUILD_CONCURRENCY_FALSE@concurrent = '-Econcurrent' 317 307 @BUILD_CONCURRENCY_TRUE@concurrent = … … 325 315 fstream_test_SOURCES = fstream_test.c 326 316 fstream_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS} 327 vector_test_SOURCES = vector/vector_int.c vector/array.c vector/vector_test.c328 vector_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}329 317 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 330 318 avl_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS} … … 390 378 @rm -f fstream_test$(EXEEXT) 391 379 $(AM_V_CCLD)$(fstream_test_LINK) $(fstream_test_OBJECTS) $(fstream_test_LDADD) $(LIBS) 392 vector/$(am__dirstamp):393 @$(MKDIR_P) vector394 @: > vector/$(am__dirstamp)395 vector/$(DEPDIR)/$(am__dirstamp):396 @$(MKDIR_P) vector/$(DEPDIR)397 @: > vector/$(DEPDIR)/$(am__dirstamp)398 vector/vector_test-vector_int.$(OBJEXT): vector/$(am__dirstamp) \399 vector/$(DEPDIR)/$(am__dirstamp)400 vector/vector_test-array.$(OBJEXT): vector/$(am__dirstamp) \401 vector/$(DEPDIR)/$(am__dirstamp)402 vector/vector_test-vector_test.$(OBJEXT): vector/$(am__dirstamp) \403 vector/$(DEPDIR)/$(am__dirstamp)404 405 vector_test$(EXEEXT): $(vector_test_OBJECTS) $(vector_test_DEPENDENCIES) $(EXTRA_vector_test_DEPENDENCIES)406 @rm -f vector_test$(EXEEXT)407 $(AM_V_CCLD)$(vector_test_LINK) $(vector_test_OBJECTS) $(vector_test_LDADD) $(LIBS)408 380 409 381 mostlyclean-compile: 410 382 -rm -f *.$(OBJEXT) 411 383 -rm -f avltree/*.$(OBJEXT) 412 -rm -f vector/*.$(OBJEXT)413 384 414 385 distclean-compile: … … 423 394 @AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl_test-avl4.Po@am__quote@ 424 395 @AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl_test-avl_test.Po@am__quote@ 425 @AMDEP_TRUE@@am__include@ @am__quote@vector/$(DEPDIR)/vector_test-array.Po@am__quote@426 @AMDEP_TRUE@@am__include@ @am__quote@vector/$(DEPDIR)/vector_test-vector_int.Po@am__quote@427 @AMDEP_TRUE@@am__include@ @am__quote@vector/$(DEPDIR)/vector_test-vector_test.Po@am__quote@428 396 429 397 .c.o: … … 554 522 @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ 555 523 @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` 556 557 vector/vector_test-vector_int.o: vector/vector_int.c558 @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.c559 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_int.Tpo vector/$(DEPDIR)/vector_test-vector_int.Po560 @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/vector_int.c' object='vector/vector_test-vector_int.o' libtool=no @AMDEPBACKSLASH@561 @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@562 @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.c563 564 vector/vector_test-vector_int.obj: vector/vector_int.c565 @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`566 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_int.Tpo vector/$(DEPDIR)/vector_test-vector_int.Po567 @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/vector_int.c' object='vector/vector_test-vector_int.obj' libtool=no @AMDEPBACKSLASH@568 @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@569 @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`570 571 vector/vector_test-array.o: vector/array.c572 @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.c573 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-array.Tpo vector/$(DEPDIR)/vector_test-array.Po574 @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/array.c' object='vector/vector_test-array.o' libtool=no @AMDEPBACKSLASH@575 @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@576 @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.c577 578 vector/vector_test-array.obj: vector/array.c579 @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`580 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-array.Tpo vector/$(DEPDIR)/vector_test-array.Po581 @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/array.c' object='vector/vector_test-array.obj' libtool=no @AMDEPBACKSLASH@582 @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@583 @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`584 585 vector/vector_test-vector_test.o: vector/vector_test.c586 @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.c587 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_test.Tpo vector/$(DEPDIR)/vector_test-vector_test.Po588 @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/vector_test.c' object='vector/vector_test-vector_test.o' libtool=no @AMDEPBACKSLASH@589 @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@590 @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.c591 592 vector/vector_test-vector_test.obj: vector/vector_test.c593 @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`594 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_test.Tpo vector/$(DEPDIR)/vector_test-vector_test.Po595 @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='vector/vector_test.c' object='vector/vector_test-vector_test.obj' libtool=no @AMDEPBACKSLASH@596 @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@597 @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`598 524 599 525 ID: $(am__tagged_files) … … 711 637 -rm -f avltree/$(DEPDIR)/$(am__dirstamp) 712 638 -rm -f avltree/$(am__dirstamp) 713 -rm -f vector/$(DEPDIR)/$(am__dirstamp)714 -rm -f vector/$(am__dirstamp)715 639 716 640 maintainer-clean-generic: … … 722 646 723 647 distclean: distclean-am 724 -rm -rf ./$(DEPDIR) avltree/$(DEPDIR) vector/$(DEPDIR)648 -rm -rf ./$(DEPDIR) avltree/$(DEPDIR) 725 649 -rm -f Makefile 726 650 distclean-am: clean-am distclean-compile distclean-generic \ … … 768 692 769 693 maintainer-clean: maintainer-clean-am 770 -rm -rf ./$(DEPDIR) avltree/$(DEPDIR) vector/$(DEPDIR)694 -rm -rf ./$(DEPDIR) avltree/$(DEPDIR) 771 695 -rm -f Makefile 772 696 maintainer-clean-am: distclean-am maintainer-clean-generic … … 827 751 ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@} 828 752 829 dtor-early-exit-ERR1: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@830 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}831 832 dtor-early-exit-ERR2: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@833 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}834 835 753 declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@ 836 754 ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@} … … 860 778 ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@} 861 779 862 memberCtors-ERR1: memberCtors.c @CFA_BINDIR@/@CFA_NAME@863 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}864 865 ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@866 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}867 868 780 completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@ 869 781 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} … … 873 785 874 786 alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@ 787 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} 788 789 # Constructor/destructor tests 790 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ 791 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} 792 793 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@ 794 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@} 795 796 raii/memberCtors-ERR1: raii/memberCtors.c @CFA_BINDIR@/@CFA_NAME@ 797 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} 798 799 raii/ctor-autogen-ERR1: raii/ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@ 875 800 ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} 876 801 -
src/tests/alloc.c
rf792cb8 r7416d46a 10 10 // Created On : Wed Feb 3 07:56:22 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Nov 24 23:06:42 201713 // Update Count : 3 1912 // Last Modified On : Mon Jan 22 21:26:40 2018 13 // Update Count : 326 14 14 // 15 15 … … 32 32 // allocation, non-array types 33 33 34 // int & r = malloc();34 // int & r = malloc(); 35 35 // r = 0xdeadbeef; 36 36 // printf( "C malloc %#x\n", r ); 37 37 // free( &r ); 38 38 39 p = (int *) (void *)malloc( sizeof(*p) );// C malloc, type unsafe39 p = (int *)malloc( sizeof(*p) ); // C malloc, type unsafe 40 40 *p = 0xdeadbeef; 41 41 printf( "C malloc %#x\n", *p ); … … 88 88 printf( "\n" ); 89 89 90 p = (int *) (void *)realloc( p, dim * sizeof(*p) );// C realloc90 p = (int *)realloc( p, dim * sizeof(*p) ); // C realloc 91 91 for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } 92 92 printf( "C realloc\n" ); … … 259 259 free( p ); 260 260 261 #ifdef ERR1 261 262 stp = malloc(); 262 263 printf( "\nSHOULD FAIL\n" ); 263 #ifdef ERR1 264 p = alloc( stp, dim * sizeof( *stp) );264 p = realloc( stp, dim * sizeof( *stp ) ); 265 p = alloc( stp, dim * sizeof( *stp ) ); 265 266 p = memset( stp, 10 ); 266 267 p = memcpy( &st1, &st ); -
src/tests/concurrent/examples/quickSort.c
rf792cb8 r7416d46a 1 // 1 // 2 2 // The contents of this file are covered under the licence agreement in the 3 3 // file "LICENCE" distributed with Cforall. 4 // 4 // 5 5 // quickSort.c -- In-place concurrent quick-sort: threads are created to partition to a specific depth, then sequential 6 6 // recursive-calls are use to sort each partition. 7 // 7 // 8 8 // Author : Peter A. Buhr 9 9 // Created On : Wed Dec 6 12:15:52 2017 10 10 // Last Modified By : Peter A. Buhr 11 // Last Modified On : Thu Dec 14 11:20:40 201712 // Update Count : 1 4213 // 11 // Last Modified On : Mon Jan 29 08:41:37 2018 12 // Update Count : 155 13 // 14 14 15 15 #include <fstream> … … 19 19 #include <string.h> // strcmp 20 20 21 forall( otype T | { int ?<?( T, T ); } )22 21 thread Quicksort { 23 T * values;// communication variables22 int * values; // communication variables 24 23 int low, high, depth; 25 24 }; 26 25 27 forall( otype T | { int ?<?( T, T ); } ) 28 void ?{}( Quicksort(T) & qs, T values[], int size, int depth ) { 26 void ?{}( Quicksort & qs, int values[], int size, int depth ) { 29 27 qs.values = values; qs.low = 0; qs.high = size; qs.depth = depth; 30 28 } // Quicksort 31 29 32 forall( otype T | { int ?<?( T, T ); } ) 33 void main( Quicksort(T) & qs ) { 30 void main( Quicksort & qs ) { // thread starts here 34 31 // nested routines: information hiding 35 32 36 void ?{}( Quicksort (T) & qs, Tvalues[], int low, int high, int depth ) {33 void ?{}( Quicksort & qs, int values[], int low, int high, int depth ) { 37 34 qs.values = values; qs.low = low; qs.high = high; qs.depth = depth; 38 35 } // Quicksort 39 36 40 void sort( Tvalues[], int low, int high, int depth ) {37 void sort( int values[], int low, int high, int depth ) { 41 38 int left, right; // index to left/right-hand side of the values 42 Tpivot; // pivot value of values43 T swap;// temporary39 int pivot; // pivot value of values 40 int swap; // temporary 44 41 45 42 //verify(); // check for stack overflow due to recursion … … 67 64 if ( depth > 0 ) { 68 65 depth -= 1; 69 //sout << &uThisTask() << " " << depth << endl; 70 Quicksort(T) rqs = { values, low, right, depth }; // concurrently sort upper half 66 Quicksort rqs = { values, low, right, depth }; // concurrently sort upper half 71 67 //Quicksort lqs( values, left, high, depth ); // concurrently sort lower half 72 68 sort( values, left, high, depth ); // concurrently sort lower half … … 97 93 98 94 99 #define ELEMTYPE int100 101 95 int main( int argc, char * argv[] ) { 102 96 ifstream & unsortedfile = sin; … … 106 100 if ( argc != 1 ) { // do not use defaults 107 101 if ( argc < 2 || argc > 4 ) usage( argv ); // wrong number of options 108 if ( strcmp( argv[1], "-s" ) == 0 ) { 109 choose ( argc ) { 110 case 4: 111 &sortedfile = new( (const char *)argv[3] ); // open the output file 112 if ( fail( sortedfile ) ) { 113 serr | "Error! Could not open sorted output file \"" | argv[3] | "\"" | endl; 114 usage( argv ); 115 } // if 116 fallthrough; 117 case 3: 118 &unsortedfile = new( (const char *)argv[2] ); // open the input file 119 if ( fail( unsortedfile ) ) { 120 serr | "Error! Could not open unsorted input file \"" | argv[2] | "\"" | endl; 121 usage( argv ); 122 } // if 123 } // choose 124 } else if ( strcmp( argv[1], "-t" ) == 0 ) { 125 unsortedfile = *(ifstream *)0; // no input 102 // if ( strcmp( argv[1], "-t" ) == 0 ) { // timing ? 103 if ( argv[1][0] == '-' && argv[1][1] == 't' ) { // timing ? 104 &unsortedfile = (ifstream *)0; // no input 126 105 choose ( argc ) { 127 106 case 4: … … 131 110 if ( ! convert( size, argv[2] ) || size < 0 ) usage( argv ); 132 111 } // choose 133 } else usage( argv ); // invalid flag 112 } else { // sort file 113 choose ( argc ) { 114 case 3: 115 &sortedfile = new( (const char *)argv[2] ); // open the output file 116 if ( fail( sortedfile ) ) { 117 serr | "Error! Could not open sorted output file \"" | argv[2] | "\"" | endl; 118 usage( argv ); 119 } // if 120 fallthrough; 121 case 2: 122 &unsortedfile = new( (const char *)argv[1] ); // open the input file 123 if ( fail( unsortedfile ) ) { 124 serr | "Error! Could not open unsorted input file \"" | argv[1] | "\"" | endl; 125 usage( argv ); 126 } // if 127 } // choose 128 } // if 134 129 } // if 135 130 … … 140 135 unsortedfile | size; // read number of elements in the list 141 136 if ( eof( unsortedfile ) ) break; 142 // ELEMTYPE * values = anew( size ); // values to be sorted, too large to put on stack 143 ELEMTYPE * values = alloc( size ); // values to be sorted, too large to put on stack 144 // ELEMTYPE * values = (ELEMTYPE *)malloc( sizeof(ELEMTYPE) * size ); 137 int * values = alloc( size ); // values to be sorted, too large to put on stack 145 138 for ( int counter = 0; counter < size; counter += 1 ) { // read unsorted numbers 146 139 unsortedfile | values[counter]; … … 151 144 sortedfile | endl; 152 145 if ( size > 0 ) { // values to sort ? 153 Quicksort (ELEMTYPE)QS = { values, size - 1, 0 }; // sort values146 Quicksort QS = { values, size - 1, 0 }; // sort values 154 147 } // wait until sort tasks terminate 155 148 for ( int counter = 0; counter < size; counter += 1 ) { // print sorted list … … 167 160 processor processors[ (1 << depth) - 1 ] __attribute__(( unused )); // create 2^depth-1 kernel threads 168 161 169 // ELEMTYPE * values = anew( size ); // values to be sorted, too large to put on stack 170 ELEMTYPE * values = alloc( size ); // values to be sorted, too large to put on stack 162 int * values = alloc( size ); // values to be sorted, too large to put on stack 171 163 for ( int counter = 0; counter < size; counter += 1 ) { // generate unsorted numbers 172 164 values[counter] = size - counter; // descending values 173 165 } // for 174 166 { 175 Quicksort (ELEMTYPE)QS = { values, size - 1, depth }; // sort values167 Quicksort QS = { values, size - 1, depth }; // sort values 176 168 } // wait until sort tasks terminate 177 169 -
src/tests/io.c
rf792cb8 r7416d46a 10 10 // Created On : Wed Mar 2 16:56:02 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Dec 6 23:15:42 201713 // Update Count : 8812 // Last Modified On : Fri Jan 26 15:19:34 2018 13 // Update Count : 100 14 14 // 15 15 … … 17 17 18 18 int main() { 19 char c; // basic types 19 _Bool b; // basic types 20 char c; 20 21 signed char sc; 21 22 unsigned char usc; … … 90 91 91 92 sout | "input bacis types" | endl; 92 in | c | sc | usc // character 93 in | b // boolean 94 | c | sc | usc // character 93 95 | si | usi | i | ui | li | uli | lli | ulli // integral 94 96 | f | d | ld // floating point … … 98 100 99 101 sout | "output basic types" | endl; 100 sout | c | ' ' | sc | ' ' | usc | endl // character 102 sout | b | endl // boolean 103 | c | ' ' | sc | ' ' | usc | endl // character 101 104 | si | usi | i | ui | li | uli | lli | ulli | endl // integral 102 105 | f | d | ld | endl // floating point -
src/tests/io.data
rf792cb8 r7416d46a 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 xyz1 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 -
src/tests/raii/.expect/ctor-autogen-ERR1.txt
rf792cb8 r7416d46a 1 ctor-autogen.c:102:1 error: No reasonable alternatives for expression Applying untyped:1 raii/ctor-autogen.c:102:1 error: No reasonable alternatives for expression Applying untyped: 2 2 Name: ?{} 3 3 ...to: -
src/tests/sum.c
rf792cb8 r7416d46a 11 11 // Created On : Wed May 27 17:56:53 2015 12 12 // Last Modified By : Peter A. Buhr 13 // Last Modified On : Thu Dec 7 09:13:36 201714 // Update Count : 2 6113 // Last Modified On : Fri Jan 26 11:31:02 2018 14 // Update Count : 271 15 15 // 16 16 17 17 #include <fstream> 18 #include <stdlib> 18 19 19 20 void ?{}( int & c, zero_t ) { c = 0; } … … 28 29 29 30 forall( otype T | sumable( T ) ) // use trait 30 T sum( unsigned int n, T a[] ) {31 T total = 0; // instantiate T , select 032 for ( unsigned int i = 0; i < n; i += 1 )33 total += a[i]; // select +31 T sum( unsigned int size, T a[] ) { 32 T total = 0; // instantiate T from 0 by calling constructor 33 for ( unsigned int i = 0; i < size; i += 1 ) 34 total += a[i]; // select appropriate + 34 35 return total; 35 36 } // sum … … 55 56 } // for 56 57 sout | "sum from" | low | "to" | High | "is" 57 | sum( size, (unsigned char *)a ) | ", check" | (int)s | endl;58 | sum( size, (unsigned char *)a ) | ", check" | (int)s | endl; 58 59 59 60 int s = 0, a[size], v = low; … … 63 64 } // for 64 65 sout | "sum from" | low | "to" | High | "is" 65 | sum( size, (int *)a ) | ", check" | (int)s | endl;66 | sum( size, (int *)a ) | ", check" | (int)s | endl; 66 67 67 68 float s = 0.0f, a[size], v = low / 10.0f; … … 71 72 } // for 72 73 sout | "sum from" | low / 10.0f | "to" | High / 10.0f | "is" 73 | sum( size, (float *)a ) | ", check" | (float)s | endl;74 | sum( size, (float *)a ) | ", check" | (float)s | endl; 74 75 75 76 double s = 0.0, a[size], v = low / 10.0; … … 79 80 } // for 80 81 sout | "sum from" | low / 10.0 | "to" | High / 10.0 | "is" 81 | sum( size, (double *)a ) | ", check" | (double)s | endl;82 | sum( size, (double *)a ) | ", check" | (double)s | endl; 82 83 83 84 struct S { int i, j; }; … … 98 99 } // for 99 100 sout | "sum from" | low | "to" | High | "is" 100 | sum( size, (S *)a ) | ", check" | (S)s | endl; 101 | sum( size, (S *)a ) | ", check" | (S)s | endl; 102 103 forall( otype Impl | sumable( Impl ) ) 104 struct GS { 105 Impl * x, * y; 106 }; 107 GS(int) gs; 108 gs.x = anew( size ); // create array storage for field 109 s = 0; v = low; 110 for ( int i = 0; i < size; i += 1, v += 1 ) { 111 s += (int)v; 112 gs.x[i] = (int)v; // set filed array in generic type 113 } // for 114 sout | "sum from" | low | "to" | High | "is" 115 | sum( size, gs.x ) | ", check" | (int)s | endl; // add filed array in generic type 101 116 } // main 102 117 -
src/tests/vector.c
rf792cb8 r7416d46a 5 5 // file "LICENCE" distributed with Cforall. 6 6 // 7 // libcfa_vector.c --7 // vector.c -- 8 8 // 9 9 // Author : Thierry Delisle 10 10 // Created On : Mon Jul 4 23:36:19 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : T ue Jul 5 15:08:05 201613 // Update Count : 2 612 // Last Modified On : Thu Jan 18 17:08:08 2018 13 // Update Count : 27 14 14 // 15 15 … … 63 63 // Local Variables: // 64 64 // tab-width: 4 // 65 // compile-command: "cfa libcfa_vector.c" //65 // compile-command: "cfa vector.c" // 66 66 // End: //
Note:
See TracChangeset
for help on using the changeset viewer.