Changes in / [249d6e6:863c413]


Ignore:
Location:
src
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/TypedefTable.cc

    r249d6e6 r863c413  
    1010// Created On       : Sat May 16 15:20:13 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jun  1 16:54:18 2018
    13 // Update Count     : 155
     12// Last Modified On : Wed May 30 18:04:38 2018
     13// Update Count     : 148
    1414//
    1515
    … …  
    5454void TypedefTable::makeTypedef( const string & name ) {
    5555        if ( ! typedefTable.exists( name ) ) {
    56                 typedefTable.addToEnclosingScope( name, TYPEDEFname, "MTD" );
     56                typedefTable.addToEnclosingScope( name, TYPEDEFname /*, "MTD"*/ );
    5757        } // if
    5858} // TypedefTable::makeTypedef
    5959
    60 void TypedefTable::addToScope( const std::string & identifier, int kind, const char * locn __attribute__((unused)) ) {
     60void TypedefTable::addToScope( const std::string & identifier, int kind /*, const char * locn*/ ) {
    6161        auto scope = kindTable.currentScope();
    62         debugPrint( cerr << "Adding at " << locn << " " << identifier << " as kind " << kind << " scope " << scope << endl );
     62        debugPrint( cerr << "Adding at " /* << locn */ << " " << identifier << " as kind " << kind << " scope " << scope << endl );
    6363        auto ret = kindTable.insertAt( scope, identifier, kind );
    6464        if ( ! ret.second ) ret.first->second = kind;           // exists => update
    6565} // TypedefTable::addToScope
    6666
    67 void TypedefTable::addToEnclosingScope( const std::string & identifier, int kind, const char * locn __attribute__((unused)) ) {
     67void TypedefTable::addToEnclosingScope( const std::string & identifier, int kind /*, const char * locn*/ ) {
    6868        assert( kindTable.currentScope() >= 1 );
    6969        auto scope = kindTable.currentScope() - 1;
    70         debugPrint( cerr << "Adding+1 at " << locn << " " << identifier << " as kind " << kind << " scope " << scope << endl );
     70        debugPrint( cerr << "Adding2 at " /* << locn */ << " " << identifier << " as kind " << kind << " scope " << scope << endl );
    7171        auto ret = kindTable.insertAt( scope, identifier, kind );
    7272        if ( ! ret.second ) ret.first->second = kind;           // exists => update

  • src/Parser/TypedefTable.h

    r249d6e6 r863c413  
    1010// Created On       : Sat May 16 15:24:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May 31 23:23:47 2018
    13 // Update Count     : 83
     12// Last Modified On : Wed May 30 17:02:49 2018
     13// Update Count     : 82
    1414//
    1515
    … …  
    3232        void changeKind( const std::string & identifier, int kind );
    3333        void makeTypedef( const std::string & name );
    34         void addToScope( const std::string & identifier, int kind, const char * );
    35         void addToEnclosingScope( const std::string & identifier, int kind, const char * );
     34        void addToScope( const std::string & identifier, int kind /*, const char **/ );
     35        void addToEnclosingScope( const std::string & identifier, int kind /*, const char */ );
    3636
    3737        void enterScope();

  • src/Parser/parser.yy

    r249d6e6 r863c413  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jun  1 17:59:57 2018
    13 // Update Count     : 3476
     12// Last Modified On : Thu May 31 15:11:40 2018
     13// Update Count     : 3444
    1414//
    1515
    … …  
    304304%type<en> enumerator_value_opt
    305305
    306 %type<decl> exception_declaration external_definition external_definition_list external_definition_list_no_pop_push external_definition_list_opt
     306%type<decl> exception_declaration external_definition external_definition_list external_definition_list_opt
    307307
    308308%type<decl> field_declaration field_declaration_list_opt field_declarator_opt field_declaring_list
    … …  
    644644                // semantics checks, e.g., ++3, 3--, *3, &&3
    645645        | constant
     646                { $$ = $1; }
    646647        | string_literal
    647648                { $$ = new ExpressionNode( $1 ); }
    … …  
    987988                { $$ = new StatementNode( build_if( $3, $5, $7 ) ); }
    988989        ;
     990
    989991
    990992if_control_expression:
    … …  
    13811383cfa_function_declaration:                                                               // CFA
    13821384        cfa_function_specifier
     1385                { $$ = $1; }
    13831386        | type_qualifier_list cfa_function_specifier
    13841387                { $$ = $2->addQualifiers( $1 ); }
    … …  
    14371440        TYPEDEF cfa_variable_specifier
    14381441                {
    1439                         typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "1" );
     1442                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname /*, "1"*/ );
    14401443                        $$ = $2->addTypedef();
    14411444                }
    14421445        | TYPEDEF cfa_function_specifier
    14431446                {
    1444                         typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "2" );
     1447                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname /*, "2"*/ );
    14451448                        $$ = $2->addTypedef();
    14461449                }
    14471450        | cfa_typedef_declaration pop ',' push no_attr_identifier
    14481451                {
    1449                         typedefTable.addToEnclosingScope( *$5, TYPEDEFname, "3" );
     1452                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname /*, "3"*/ );
    14501453                        $$ = $1->appendList( $1->cloneType( $5 ) );
    14511454                }
    … …  
    14581461        TYPEDEF type_specifier declarator
    14591462                {
    1460                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
     1463                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname /*, "4"*/ );
    14611464                        $$ = $3->addType( $2 )->addTypedef();
    14621465                }
    14631466        | typedef_declaration pop ',' push declarator
    14641467                {
    1465                         typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname, "5" );
     1468                        typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname /*, "5"*/ );
    14661469                        $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
    14671470                }
    14681471        | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
    14691472                {
    1470                         typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" );
     1473                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname /*, "6"*/ );
    14711474                        $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
    14721475                }
    14731476        | type_specifier TYPEDEF declarator
    14741477                {
    1475                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "7" );
     1478                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname /*, "7"*/ );
    14761479                        $$ = $3->addType( $1 )->addTypedef();
    14771480                }
    14781481        | type_specifier TYPEDEF type_qualifier_list declarator
    14791482                {
    1480                         typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" );
     1483                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname /*, "8"*/ );
    14811484                        $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
    14821485                }
    … …  
    19341937                { $$ = nullptr; }
    19351938        | bit_subrange_size
     1939                { $$ = $1; }
    19361940        ;
    19371941
    … …  
    21832187type_parameter_list:                                                                    // CFA
    21842188        type_parameter
     2189                { $$ = $1; }
    21852190        | type_parameter_list ',' type_parameter
    21862191                { $$ = $1->appendList( $3 ); }
    … …  
    21962201type_parameter:                                                                                 // CFA
    21972202        type_class no_attr_identifier_or_type_name
    2198                 { typedefTable.addToScope( *$2, TYPEDEFname, "9" ); }
     2203                { typedefTable.addToScope( *$2, TYPEDEFname /*, "9"*/ ); }
    21992204          type_initializer_opt assertion_list_opt
    22002205                { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
    … …  
    22652270        no_attr_identifier_or_type_name
    22662271                {
    2267                         typedefTable.addToEnclosingScope( *$1, TYPEDEFname, "10" );
     2272                        typedefTable.addToEnclosingScope( *$1, TYPEDEFname /*, "10"*/ );
    22682273                        $$ = DeclarationNode::newTypeDecl( $1, 0 );
    22692274                }
    22702275        | no_attr_identifier_or_type_name '(' type_parameter_list ')'
    22712276                {
    2272                         typedefTable.addToEnclosingScope( *$1, TYPEGENname, "11" );
     2277                        typedefTable.addToEnclosingScope( *$1, TYPEGENname /*, "11"*/ );
    22732278                        $$ = DeclarationNode::newTypeDecl( $1, $3 );
    22742279                }
    … …  
    23252330        ;
    23262331
    2327         // SKULLDUGGERY: Declarations in extern "X" and distribution need to be added to the current lexical scope.
    2328         // However, external_definition_list creates a new scope around each external_definition, but the pop loses all the
    2329         // types in the extern "X" and distribution at the end of the block. This version of external_definition_list does
    2330 
    2331         // not do push/pop for declarations at the level of the extern "X" and distribution block. Any recursive uses of
    2332         // external_definition_list within the extern "X" and distribution block correctly pushes/pops for that scope level.
    2333 external_definition_list_no_pop_push:
    2334         external_definition
    2335         | external_definition_list_no_pop_push
    2336                 { forall = xxx; }
    2337           external_definition
    2338                 { $$ = $1 ? $1->appendList( $3 ) : $3; }
    2339         ;
    2340 
    23412332external_definition_list_opt:
    23422333        // empty
    23432334                { $$ = nullptr; }
    2344         | external_definition_list_no_pop_push
     2335        | external_definition_list
    23452336        ;
    23462337
    … …  
    23482339        declaration
    23492340        | external_function_definition
     2341        | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
     2342                {
     2343                        $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) );
     2344                }
     2345        | EXTERN STRINGliteral                                                          // C++-style linkage specifier
     2346                {
     2347                        linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
     2348                        linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
     2349                }
     2350                        // SKULLDUGGERY: Declarations in extern "X" need to be added to the current lexical scope.  However,
     2351                        // external_definition_list_opt creates a new scope that loses the types at the end of the extern block. The
     2352                        // correction is a pop/push (reverse order) to undo the push/pop from external_definition_list_opt.  This
     2353                        // trick works for nested extern "X"s, as each one undoes itself in the nesting.
     2354          '{' pop external_definition_list_opt push '}'
     2355                {
     2356                        linkage = linkageStack.top();
     2357                        linkageStack.pop();
     2358                        $$ = $6;
     2359                }
    23502360        | EXTENSION external_definition                                         // GCC, multiple __extension__ allowed, meaning unknown
    23512361                {
    … …  
    23532363                        $$ = $2;
    23542364                }
    2355         | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
    2356                 {
    2357                         $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) );
    2358                 }
    2359         | EXTERN STRINGliteral                                                          // C++-style linkage specifier
    2360                 {
    2361                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
    2362                         linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
    2363                 }
    2364           '{' external_definition_list_opt '}'
    2365                 {
    2366                         linkage = linkageStack.top();
    2367                         linkageStack.pop();
    2368                         $$ = $5;
    2369                 }
    23702365        | type_qualifier_list
    23712366                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
    2372           '{' external_definition_list_opt '}'                          // CFA, namespace
     2367          '{' external_definition_list push '}'                  // CFA, namespace
    23732368                {
    23742369                        for ( DeclarationNode * iter = $4; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
    … …  
    23832378        | declaration_qualifier_list
    23842379                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
    2385           '{' external_definition_list_opt '}'                          // CFA, namespace
     2380          '{' external_definition_list '}'                                       // CFA, namespace
    23862381                {
    23872382                        for ( DeclarationNode * iter = $4; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
    … …  
    23992394                        if ( $2->type->forall ) xxx = forall = true; // remember generic type
    24002395                }
    2401           '{' external_definition_list_opt '}'                          // CFA, namespace
     2396          '{' external_definition_list '}'                                      // CFA, namespace
    24022397                {
    24032398                        for ( DeclarationNode * iter = $5; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
    … …  
    27202715        typedef
    27212716                // hide type name in enclosing scope by variable name
    2722                 { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" ); }
     2717                { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER /*, "ID"*/ ); }
    27232718        | '(' paren_type ')'
    27242719                { $$ = $2; }

  • src/ResolvExpr/AdjustExprType.cc

    r249d6e6 r863c413  
    6666
    6767        Type * AdjustExprType::postmutate( ArrayType * arrayType ) {
    68                 PointerType *pointerType = new PointerType{ arrayType->get_qualifiers(), arrayType->base };
     68                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base );
    6969                arrayType->base = nullptr;
    7070                delete arrayType;
    … …  
    7373
    7474        Type * AdjustExprType::postmutate( FunctionType * functionType ) {
    75                 return new PointerType{ Type::Qualifiers(), functionType };
     75                return new PointerType( Type::Qualifiers(), functionType );
    7676        }
    7777
    7878        Type * AdjustExprType::postmutate( TypeInstType * typeInst ) {
    79                 if ( const EqvClass* eqvClass = env.lookup( typeInst->get_name() ) ) {
    80                         if ( eqvClass->data.kind == TypeDecl::Ftype ) {
    81                                 return new PointerType{ Type::Qualifiers(), typeInst };
     79                EqvClass eqvClass;
     80                if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
     81                        if ( eqvClass.data.kind == TypeDecl::Ftype ) {
     82                                PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
     83                                return pointerType;
    8284                        }
    8385                } else if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
    8486                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
    8587                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
    86                                         return new PointerType{ Type::Qualifiers(), typeInst };
     88                                        PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
     89                                        return pointerType;
    8790                                } // if
    8891                        } // if

  • src/ResolvExpr/AlternativeFinder.cc

    r249d6e6 r863c413  
    102102                void addAnonConversions( const Alternative & alt );
    103103                /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
    104                 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name );
     104                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
    105105                /// Adds alternatives for member expressions where the left side has tuple type
    106106                void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
    … …  
    307307
    308308                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->result ) ) {
    309                         addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
     309                        NameExpr nameExpr( "" );
     310                        addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
    310311                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->result ) ) {
    311                         addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
     312                        NameExpr nameExpr( "" );
     313                        addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
    312314                } // if
    313315        }
    314316
    315317        template< typename StructOrUnionType >
    316         void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name ) {
     318        void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
     319                // by this point, member must be a name expr
     320                NameExpr * nameExpr = dynamic_cast< NameExpr * >( member );
     321                if ( ! nameExpr ) return;
     322                const std::string & name = nameExpr->name;
    317323                std::list< Declaration* > members;
    318324                aggInst->lookup( name, members );
    … …  
    466472        }
    467473
     474        // /// Map of declaration uniqueIds (intended to be the assertions in an AssertionSet) to their parents and the number of times they've been included
     475        //typedef std::unordered_map< UniqueId, std::unordered_map< UniqueId, unsigned > > AssertionParentSet;
     476
    468477        static const int recursionLimit = /*10*/ 4;  ///< Limit to depth of recursion satisfaction
     478        //static const unsigned recursionParentLimit = 1;  ///< Limit to the number of times an assertion can recursively use itself
    469479
    470480        void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
    … …  
    477487
    478488        template< typename ForwardIterator, typename OutputIterator >
    479         void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, int level, const SymTab::Indexer &indexer, OutputIterator out ) {
     489        void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, /*const AssertionParentSet &needParents,*/
     490                                                 int level, const SymTab::Indexer &indexer, OutputIterator out ) {
    480491                if ( begin == end ) {
    481492                        if ( newNeed.empty() ) {
    … …  
    495506                                        printAssertionSet( newNeed, std::cerr, 8 );
    496507                                )
    497                                 inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, level+1, indexer, out );
     508                                inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, /*needParents,*/ level+1, indexer, out );
    498509                                return;
    499510                        }
    … …  
    502513                ForwardIterator cur = begin++;
    503514                if ( ! cur->second.isUsed ) {
    504                         inferRecursive( begin, end, newAlt, openVars, decls, newNeed, level, indexer, out );
     515                        inferRecursive( begin, end, newAlt, openVars, decls, newNeed, /*needParents,*/ level, indexer, out );
    505516                        return; // xxx - should this continue? previously this wasn't here, and it looks like it should be
    506517                }
    … …  
    555566                                }
    556567
     568                                //AssertionParentSet newNeedParents( needParents );
     569                                // skip repeatingly-self-recursive assertion satisfaction
     570                                // DOESN'T WORK: grandchild nodes conflict with their cousins
     571                                //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
     572
    557573                                Expression *varExpr = data.combine( newerAlt.cvtCost );
    558574                                delete varExpr->get_result();
    … …  
    572588                                // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
    573589                                (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
    574                                 inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
     590                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
    575591                        } else {
    576592                                delete adjType;
    … …  
    594610                addToIndexer( have, decls );
    595611                AssertionSet newNeed;
     612                //AssertionParentSet needParents;
    596613                PRINT(
    597614                        std::cerr << "env is: " << std::endl;
    … …  
    600617                )
    601618
    602                 inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
     619                inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, /*needParents,*/ 0, indexer, out );
    603620//      PRINT(
    604621//          std::cerr << "declaration 14 is ";
    … …  
    10791096                AlternativeFinder funcOpFinder( indexer, env );
    10801097                // it's ok if there aren't any defined function ops
    1081                 funcOpFinder.maybeFind( opExpr );
     1098                funcOpFinder.maybeFind( opExpr);
    10821099                PRINT(
    10831100                        std::cerr << "known function ops:" << std::endl;
    … …  
    11161133                                        }
    11171134                                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->result->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer)
    1118                                         if ( const EqvClass *eqvClass = func->env.lookup( typeInst->name ) ) {
    1119                                                 if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass->type ) ) {
     1135                                        EqvClass eqvClass;
     1136                                        if ( func->env.lookup( typeInst->name, eqvClass ) && eqvClass.type ) {
     1137                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
    11201138                                                        Alternative newFunc( *func );
    11211139                                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );
    … …  
    13321350        }
    13331351
    1334         namespace {
    1335                 /// Gets name from untyped member expression (member must be NameExpr)
    1336                 const std::string& get_member_name( UntypedMemberExpr *memberExpr ) {
    1337                         NameExpr * nameExpr = dynamic_cast< NameExpr * >( memberExpr->get_member() );
    1338                         assert( nameExpr );
    1339                         return nameExpr->get_name();
    1340                 }
    1341         }
    1342 
    13431352        void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) {
    13441353                AlternativeFinder funcFinder( indexer, env );
    … …  
    13531362                        // find member of the given type
    13541363                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
    1355                                 addAggMembers( structInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
     1364                                addAggMembers( structInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
    13561365                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
    1357                                 addAggMembers( unionInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
     1366                                addAggMembers( unionInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
    13581367                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
    13591368                                addTupleMembers( tupleType, aggrExpr, cost, agg->env, memberExpr->get_member() );

  • src/ResolvExpr/CastCost.cc

    r249d6e6 r863c413  
    4343        Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    4444                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    45                         if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
    46                                 if ( eqvClass->type ) {
    47                                         return castCost( src, eqvClass->type, indexer, env );
     45                        EqvClass eqvClass;
     46                        NamedTypeDecl *namedType;
     47                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
     48                                if ( eqvClass.type ) {
     49                                        return castCost( src, eqvClass.type, indexer, env );
    4850                                } else {
    4951                                        return Cost::infinity;
    5052                                }
    51                         } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) {
     53                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
    5254                                // all typedefs should be gone by this point
    5355                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );

  • src/ResolvExpr/ConversionCost.cc

    r249d6e6 r863c413  
    4242        Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    4343                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
     44                        EqvClass eqvClass;
     45                        NamedTypeDecl *namedType;
    4446                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
    45                         if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->name ) ) {
    46                                 if ( eqvClass->type ) {
    47                                         return conversionCost( src, eqvClass->type, indexer, env );
     47                        if ( env.lookup( destAsTypeInst->name, eqvClass ) ) {
     48                                if ( eqvClass.type ) {
     49                                        return conversionCost( src, eqvClass.type, indexer, env );
    4850                                } else {
    4951                                        return Cost::infinity;
    5052                                }
    51                         } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->name ) ) {
     53                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) {
    5254                                PRINT( std::cerr << " found" << std::endl; )
    5355                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    … …  
    367369
    368370        void ConversionCost::postvisit( TypeInstType *inst ) {
    369                 if ( const EqvClass *eqvClass = env.lookup( inst->name ) ) {
    370                         cost = costFunc( eqvClass->type, dest, indexer, env );
     371                EqvClass eqvClass;
     372                NamedTypeDecl *namedType;
     373                if ( env.lookup( inst->name, eqvClass ) ) {
     374                        cost = costFunc( eqvClass.type, dest, indexer, env );
    371375                } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) {
    372376                        if ( inst->name == destAsInst->name ) {
    373377                                cost = Cost::zero;
    374378                        }
    375                 } else if ( NamedTypeDecl *namedType = indexer.lookupType( inst->name ) ) {
     379                } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) {
    376380                        TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    377381                        // all typedefs should be gone by this point

  • src/ResolvExpr/Occurs.cc

    r249d6e6 r863c413  
    3838
    3939        Occurs::Occurs( std::string varName, const TypeEnvironment & env ) : result( false ), tenv( env ) {
    40                 if ( const EqvClass *eqvClass = tenv.lookup( varName ) ) {
    41                         eqvVars = eqvClass->vars;
     40                EqvClass eqvClass;
     41                if ( tenv.lookup( varName, eqvClass ) ) {
     42                        eqvVars = eqvClass.vars;
    4243                } else {
    4344                        eqvVars.insert( varName );
    … …  
    4647
    4748        void Occurs::previsit( TypeInstType * typeInst ) {
    48                 ///   std::cerr << "searching for vars: ";
     49                EqvClass eqvClass;
     50///   std::cerr << "searching for vars: ";
    4951///   std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::cerr, " " ) );
    5052///   std::cerr << std::endl;
    5153                if ( eqvVars.find( typeInst->get_name() ) != eqvVars.end() ) {
    5254                        result = true;
    53                 } else if ( const EqvClass *eqvClass = tenv.lookup( typeInst->get_name() ) ) {
    54                         if ( eqvClass->type ) {
     55                } else if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
     56                        if ( eqvClass.type ) {
    5557///       std::cerr << typeInst->get_name() << " is bound to";
    5658///       eqvClass.type->print( std::cerr );
    5759///       std::cerr << std::endl;
    58                                 eqvClass->type->accept( *visitor );
     60                                eqvClass.type->accept( *visitor );
    5961                        } // if
    6062                } // if

  • src/ResolvExpr/PolyCost.cc

    r249d6e6 r863c413  
    3939
    4040        void PolyCost::previsit(TypeInstType * typeInst) {
    41                 if ( const EqvClass *eqvClass = tenv.lookup( typeInst->name ) ) {
    42                         if ( eqvClass->type ) {
    43                                 if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass->type ) ) {
     41                EqvClass eqvClass;
     42                if ( tenv.lookup( typeInst->name, eqvClass ) ) {
     43                        if ( eqvClass.type ) {
     44                                if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass.type ) ) {
    4445                                        if ( indexer.lookupType( otherTypeInst->name ) ) {
    4546                                                // bound to opaque type

  • src/ResolvExpr/PtrsAssignable.cc

    r249d6e6 r863c413  
    5151                // std::cerr << "assignable: " << src << " | " << dest << std::endl;
    5252                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    53                         if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
    54                                 return ptrsAssignable( src, eqvClass->type, env );
     53                        EqvClass eqvClass;
     54                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
     55                                return ptrsAssignable( src, eqvClass.type, env );
    5556                        } // if
    5657                } // if
    … …  
    9495        void PtrsAssignable::postvisit(  __attribute__((unused)) TraitInstType *inst ) {}
    9596        void PtrsAssignable::postvisit( TypeInstType *inst ) {
    96                 if ( const EqvClass *eqvClass = env.lookup( inst->get_name() ) ) {
    97                         if ( eqvClass->type ) {
    98                                 // T * = S * for any S depends on the type bound to T
    99                                 result = ptrsAssignable( eqvClass->type, dest, env );
    100                         }
     97                EqvClass eqvClass;
     98                if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) {
     99                        // T * = S * for any S depends on the type bound to T
     100                        result = ptrsAssignable( eqvClass.type, dest, env );
    101101                } // if
    102102        }

  • src/ResolvExpr/PtrsCastable.cc

    r249d6e6 r863c413  
    5757                                return -1;
    5858                        } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( src ) ) {
     59                                EqvClass eqvClass;
    5960                                if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
    6061                                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
    … …  
    6364                                                } // if
    6465                                        } //if
    65                                 } else if ( const EqvClass *eqvClass = env.lookup( typeInst->get_name() ) ) {
    66                                         if ( eqvClass->data.kind == TypeDecl::Ftype ) {
     66                                } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
     67                                        if ( eqvClass.data.kind == TypeDecl::Ftype ) {
    6768                                                return -1;
    6869                                        } // if
    … …  
    7879        int ptrsCastable( Type *src, Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
    7980                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    80                         if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
     81                        EqvClass eqvClass;
     82                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
    8183                                // xxx - should this be ptrsCastable?
    82                                 return ptrsAssignable( src, eqvClass->type, env );
     84                                return ptrsAssignable( src, eqvClass.type, env );
    8385                        } // if
    8486                } // if

  • src/ResolvExpr/TypeEnvironment.cc

    r249d6e6 r863c413  
    1717#include <algorithm>                   // for copy, set_intersection
    1818#include <iterator>                    // for ostream_iterator, insert_iterator
    19 #include <utility>                     // for pair, move
     19#include <utility>                     // for pair
    2020
    2121#include "Common/utility.h"            // for maybeClone
    … …  
    4444
    4545        void EqvClass::initialize( const EqvClass &src, EqvClass &dest ) {
    46                 initialize( src, dest, src.type );
    47         }
    48 
    49         void EqvClass::initialize( const EqvClass &src, EqvClass &dest, const Type *ty ) {
    5046                dest.vars = src.vars;
    51                 dest.type = maybeClone( ty );
     47                dest.type = maybeClone( src.type );
    5248                dest.allowWidening = src.allowWidening;
    5349                dest.data = src.data;
    … …  
    5955        EqvClass::EqvClass( const EqvClass &other ) {
    6056                initialize( other, *this );
    61         }
    62 
    63         EqvClass::EqvClass( const EqvClass &other, const Type *ty ) {
    64                 initialize( other, *this, ty );
    6557        }
    6658
    … …  
    9082        }
    9183
    92         const EqvClass* TypeEnvironment::lookup( const std::string &var ) const {
     84        bool TypeEnvironment::lookup( const std::string &var, EqvClass &eqvClass ) const {
    9385                for ( std::list< EqvClass >::const_iterator i = env.begin(); i != env.end(); ++i ) {
    9486                        if ( i->vars.find( var ) != i->vars.end() ) {
    9587///       std::cout << var << " is in class ";
    9688///       i->print( std::cout );
    97                                 return &*i;
     89                                eqvClass = *i;
     90                                return true;
    9891                        }
    9992///     std::cout << var << " is not in class ";
    10093///     i->print( std::cout );
    10194                } // for
    102                 return nullptr;
    103         }
    104 
    105         /// Removes any class from env that intersects eqvClass
    106         void filterOverlappingClasses( std::list<EqvClass> &env, const EqvClass &eqvClass ) {
    107                 for ( auto i = env.begin(); i != env.end(); ) {
    108                         auto next = i;
    109                         ++next;
    110                         std::set<std::string> intersection;
    111                         std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(),
    112                                 std::inserter( intersection, intersection.begin() ) );
    113                         if ( ! intersection.empty() ) { env.erase( i ); }
     95                return false;
     96        }
     97
     98        void TypeEnvironment::add( const EqvClass &eqvClass ) {
     99                std::list< EqvClass >::iterator i = env.begin();
     100                while ( i != env.end() ) {
     101                        std::list< EqvClass >::iterator next = i;
     102                        next++;
     103                        std::set< std::string > intersection;
     104                        std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(), std::inserter( intersection, intersection.begin() ) );
     105                        if ( ! intersection.empty() ) {
     106                                env.erase( i );
     107                        } // if
    114108                        i = next;
    115                 }
    116         }
    117 
    118         void TypeEnvironment::add( const EqvClass &eqvClass ) {
    119                 filterOverlappingClasses( env, eqvClass );
    120                 env.push_back( eqvClass );
    121         }
    122 
    123         void TypeEnvironment::add( EqvClass &&eqvClass ) {
    124                 filterOverlappingClasses( env, eqvClass );
    125                 env.push_back( std::move(eqvClass) );
     109                } // while
     110                env.insert( env.end(), eqvClass );
    126111        }
    127112

  • src/ResolvExpr/TypeEnvironment.h

    r249d6e6 r863c413  
    7373
    7474                void initialize( const EqvClass &src, EqvClass &dest );
    75                 void initialize( const EqvClass &src, EqvClass &dest, const Type *ty );
    7675                EqvClass();
    7776                EqvClass( const EqvClass &other );
    78                 EqvClass( const EqvClass &other, const Type *ty );
    7977                EqvClass &operator=( const EqvClass &other );
    8078                ~EqvClass();
    … …  
    8482        class TypeEnvironment {
    8583          public:
    86                 const EqvClass* lookup( const std::string &var ) const;
     84                bool lookup( const std::string &var, EqvClass &eqvClass ) const;
    8785                void add( const EqvClass &eqvClass );
    88                 void add( EqvClass &&eqvClass  );
    8986                void add( const Type::ForallList &tyDecls );
    9087                void add( const TypeSubstitution & sub );

  • src/ResolvExpr/Unify.cc

    r249d6e6 r863c413  
    2020#include <set>                    // for set
    2121#include <string>                 // for string, operator==, operator!=, bas...
    22 #include <utility>                // for pair, move
     22#include <utility>                // for pair
    2323
    2424#include "Common/PassVisitor.h"   // for PassVisitor
    … …  
    166166                        return false;
    167167                } // if
    168                 if ( const EqvClass *curClass = env.lookup( typeInst->get_name() ) ) {
    169                         if ( curClass->type ) {
     168                EqvClass curClass;
     169                if ( env.lookup( typeInst->get_name(), curClass ) ) {
     170                        if ( curClass.type ) {
    170171                                Type *common = 0;
    171172                                // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
    172                                 std::unique_ptr< Type > newType( curClass->type->clone() );
     173                                std::unique_ptr< Type > newType( curClass.type->clone() );
    173174                                newType->get_qualifiers() = typeInst->get_qualifiers();
    174                                 if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
     175                                if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) {
    175176                                        if ( common ) {
    176177                                                common->get_qualifiers() = Type::Qualifiers();
    177                                                 env.add( EqvClass{ *curClass, common } );
     178                                                delete curClass.type;
     179                                                curClass.type = common;
     180                                                env.add( curClass );
    178181                                        } // if
    179182                                        return true;
    … …  
    182185                                } // if
    183186                        } else {
    184                                 EqvClass newClass { *curClass, other };
    185                                 newClass.type->get_qualifiers() = Type::Qualifiers();
    186                                 newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
    187                                 env.add( std::move(newClass) );
     187                                curClass.type = other->clone();
     188                                curClass.type->get_qualifiers() = Type::Qualifiers();
     189                                curClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
     190                                env.add( curClass );
    188191                        } // if
    189192                } else {
    … …  
    201204        bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
    202205                bool result = true;
    203                 const EqvClass *class1 = env.lookup( var1->get_name() );
    204                 const EqvClass *class2 = env.lookup( var2->get_name() );
     206                EqvClass class1, class2;
     207                bool hasClass1 = false, hasClass2 = false;
    205208                bool widen1 = false, widen2 = false;
    206                 Type *type1 = nullptr, *type2 = nullptr;
    207 
    208                 if ( class1 ) {
    209                         if ( class1->type ) {
    210                                 if ( occurs( class1->type, var2->get_name(), env ) ) {
     209                Type *type1 = 0, *type2 = 0;
     210
     211                if ( env.lookup( var1->get_name(), class1 ) ) {
     212                        hasClass1 = true;
     213                        if ( class1.type ) {
     214                                if ( occurs( class1.type, var2->get_name(), env ) ) {
    211215                                        return false;
    212216                                } // if
    213                                 type1 = class1->type->clone();
    214                         } // if
    215                         widen1 = widenMode.widenFirst && class1->allowWidening;
    216                 } // if
    217                 if ( class2 ) {
    218                         if ( class2->type ) {
    219                                 if ( occurs( class2->type, var1->get_name(), env ) ) {
     217                                type1 = class1.type->clone();
     218                        } // if
     219                        widen1 = widenMode.widenFirst && class1.allowWidening;
     220                } // if
     221                if ( env.lookup( var2->get_name(), class2 ) ) {
     222                        hasClass2 = true;
     223                        if ( class2.type ) {
     224                                if ( occurs( class2.type, var1->get_name(), env ) ) {
    220225                                        return false;
    221226                                } // if
    222                                 type2 = class2->type->clone();
    223                         } // if
    224                         widen2 = widenMode.widenSecond && class2->allowWidening;
     227                                type2 = class2.type->clone();
     228                        } // if
     229                        widen2 = widenMode.widenSecond && class2.allowWidening;
    225230                } // if
    226231
    … …  
    230235                        Type *common = 0;
    231236                        if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, newWidenMode, indexer, common ) ) {
    232                                 EqvClass newClass1 = *class1;
    233                                 newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
    234                                 newClass1.allowWidening = widen1 && widen2;
     237                                class1.vars.insert( class2.vars.begin(), class2.vars.end() );
     238                                class1.allowWidening = widen1 && widen2;
    235239                                if ( common ) {
    236240                                        common->get_qualifiers() = Type::Qualifiers();
    237                                         delete newClass1.type;
    238                                         newClass1.type = common;
     241                                        delete class1.type;
     242                                        class1.type = common;
    239243                                } // if
    240                                 env.add( std::move(newClass1) );
     244                                env.add( class1 );
    241245                        } else {
    242246                                result = false;
    243247                        } // if
    244                 } else if ( class1 && class2 ) {
     248                } else if ( hasClass1 && hasClass2 ) {
    245249                        if ( type1 ) {
    246                                 EqvClass newClass1 = *class1;
    247                                 newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
    248                                 newClass1.allowWidening = widen1;
    249                                 env.add( std::move(newClass1) );
     250                                class1.vars.insert( class2.vars.begin(), class2.vars.end() );
     251                                class1.allowWidening = widen1;
     252                                env.add( class1 );
    250253                        } else {
    251                                 EqvClass newClass2 = *class2;
    252                                 newClass2.vars.insert( class1->vars.begin(), class1->vars.end() );
    253                                 newClass2.allowWidening = widen2;
    254                                 env.add( std::move(newClass2) );
    255                         } // if
    256                 } else if ( class1 ) {
    257                         EqvClass newClass1 = *class1;
    258                         newClass1.vars.insert( var2->get_name() );
    259                         newClass1.allowWidening = widen1;
    260                         env.add( std::move(newClass1) );
    261                 } else if ( class2 ) {
    262                         EqvClass newClass2 = *class2;
    263                         newClass2.vars.insert( var1->get_name() );
    264                         newClass2.allowWidening = widen2;
    265                         env.add( std::move(newClass2) );
     254                                class2.vars.insert( class1.vars.begin(), class1.vars.end() );
     255                                class2.allowWidening = widen2;
     256                                env.add( class2 );
     257                        } // if
     258                } else if ( hasClass1 ) {
     259                        class1.vars.insert( var2->get_name() );
     260                        class1.allowWidening = widen1;
     261                        env.add( class1 );
     262                } else if ( hasClass2 ) {
     263                        class2.vars.insert( var1->get_name() );
     264                        class2.allowWidening = widen2;
     265                        env.add( class2 );
    266266                } else {
    267267                        EqvClass newClass;
    … …  
    539539                void premutate( TypeInstType * ) { visit_children = false; }
    540540                Type * postmutate( TypeInstType * typeInst ) {
    541                         if ( const EqvClass *eqvClass = tenv.lookup( typeInst->get_name() ) ) {
    542                                 // expand ttype parameter into its actual type
    543                                 if ( eqvClass->data.kind == TypeDecl::Ttype && eqvClass->type ) {
    544                                         delete typeInst;
    545                                         return eqvClass->type->clone();
     541                        EqvClass eqvClass;
     542                        if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
     543                                if ( eqvClass.data.kind == TypeDecl::Ttype ) {
     544                                        // expand ttype parameter into its actual type
     545                                        if ( eqvClass.type ) {
     546                                                delete typeInst;
     547                                                return eqvClass.type->clone();
     548                                        }
    546549                                }
    547550                        }

  • src/libcfa/iostream

    r249d6e6 r863c413  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  2 08:07:55 2018
    13 // Update Count     : 153
     12// Last Modified On : Sat Apr 28 13:08:24 2018
     13// Update Count     : 152
    1414//
    1515
    … …  
    5656// implement writable for intrinsic types
    5757
    58 forall( dtype ostype | ostream( ostype ) ) {
    59         ostype & ?|?( ostype &, _Bool );
     58forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, _Bool );
    6059
    61         ostype & ?|?( ostype &, char );
    62         ostype & ?|?( ostype &, signed char );
    63         ostype & ?|?( ostype &, unsigned char );
     60forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, char );
     61forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, signed char );
     62forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned char );
    6463
    65         ostype & ?|?( ostype &, short int );
    66         ostype & ?|?( ostype &, unsigned short int );
    67         ostype & ?|?( ostype &, int );
    68         ostype & ?|?( ostype &, unsigned int );
    69         ostype & ?|?( ostype &, long int );
    70         ostype & ?|?( ostype &, long long int );
    71         ostype & ?|?( ostype &, unsigned long int );
    72         ostype & ?|?( ostype &, unsigned long long int );
     64forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, short int );
     65forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned short int );
     66forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, int );
     67forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned int );
     68forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long int );
     69forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long long int );
     70forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned long int );
     71forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned long long int );
    7372
    74         ostype & ?|?( ostype &, float ); // FIX ME: should not be required
    75         ostype & ?|?( ostype &, double );
    76         ostype & ?|?( ostype &, long double );
     73forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, float ); // FIX ME: should not be required
     74forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, double );
     75forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long double );
    7776
    78         ostype & ?|?( ostype &, float _Complex );
    79         ostype & ?|?( ostype &, double _Complex );
    80         ostype & ?|?( ostype &, long double _Complex );
     77forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, float _Complex );
     78forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, double _Complex );
     79forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long double _Complex );
    8180
    82         ostype & ?|?( ostype &, const char * );
    83         // ostype & ?|?( ostype &, const char16_t * );
     81forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const char * );
     82//forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const char16_t * );
    8483#if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
    85         // ostype & ?|?( ostype &, const char32_t * );
     84//forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const char32_t * );
    8685#endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
    87         // ostype & ?|?( ostype &, const wchar_t * );
    88         ostype & ?|?( ostype &, const void * );
    89 
    90         // manipulators
    91         ostype & ?|?( ostype &, ostype & (*)( ostype & ) );
    92         ostype & endl( ostype & );
    93         ostype & sep( ostype & );
    94         ostype & sepTuple( ostype & );
    95         ostype & sepOn( ostype & );
    96         ostype & sepOff( ostype & );
    97         ostype & sepDisable( ostype & );
    98         ostype & sepEnable( ostype & );
    99 } // distribution
     86//forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const wchar_t * );
     87forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const void * );
    10088
    10189// tuples
    10290forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } )
    10391ostype & ?|?( ostype & os, T arg, Params rest );
     92
     93// manipulators
     94forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, ostype & (*)( ostype & ) );
     95forall( dtype ostype | ostream( ostype ) ) ostype & endl( ostype & );
     96forall( dtype ostype | ostream( ostype ) ) ostype & sep( ostype & );
     97forall( dtype ostype | ostream( ostype ) ) ostype & sepTuple( ostype & );
     98forall( dtype ostype | ostream( ostype ) ) ostype & sepOn( ostype & );
     99forall( dtype ostype | ostream( ostype ) ) ostype & sepOff( ostype & );
     100forall( dtype ostype | ostream( ostype ) ) ostype & sepDisable( ostype & );
     101forall( dtype ostype | ostream( ostype ) ) ostype & sepEnable( ostype & );
    104102
    105103// writes the range [begin, end) to the given stream
    … …  
    126124}; // readable
    127125
    128 forall( dtype istype | istream( istype ) ) {
    129         istype & ?|?( istype &, _Bool & );
     126forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, _Bool & );
    130127
    131         istype & ?|?( istype &, char & );
    132         istype & ?|?( istype &, signed char & );
    133         istype & ?|?( istype &, unsigned char & );
     128forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, char & );
     129forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, signed char & );
     130forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned char & );
    134131
    135         istype & ?|?( istype &, short int & );
    136         istype & ?|?( istype &, unsigned short int & );
    137         istype & ?|?( istype &, int & );
    138         istype & ?|?( istype &, unsigned int & );
    139         istype & ?|?( istype &, long int & );
    140         istype & ?|?( istype &, long long int & );
    141         istype & ?|?( istype &, unsigned long int & );
    142         istype & ?|?( istype &, unsigned long long int & );
     132forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, short int & );
     133forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned short int & );
     134forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, int & );
     135forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned int & );
     136forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long int & );
     137forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long long int & );
     138forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned long int & );
     139forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned long long int & );
    143140
    144         istype & ?|?( istype &, float & );
    145         istype & ?|?( istype &, double & );
    146         istype & ?|?( istype &, long double & );
     141forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, float & );
     142forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, double & );
     143forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long double & );
    147144
    148         istype & ?|?( istype &, float _Complex & );
    149         istype & ?|?( istype &, double _Complex & );
    150         istype & ?|?( istype &, long double _Complex & );
     145forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, float _Complex & );
     146forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, double _Complex & );
     147forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long double _Complex & );
    151148
    152         // manipulators
    153         istype & ?|?( istype &, istype & (*)( istype & ) );
    154         istype & endl( istype & is );
    155 } // distribution
     149// manipulators
     150forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, istype & (*)( istype & ) );
     151forall( dtype istype | istream( istype ) ) istype & endl( istype & is );
    156152
    157153struct _Istream_cstrUC { char * s; };

  • src/libcfa/iostream.c

    r249d6e6 r863c413  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  2 08:24:56 2018
    13 // Update Count     : 471
     12// Last Modified On : Sat Apr 28 13:08:25 2018
     13// Update Count     : 469
    1414//
    1515
    … …  
    2626}
    2727
    28 forall( dtype ostype | ostream( ostype ) ) {
    29         ostype & ?|?( ostype & os, _Bool b ) {
    30                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    31                 fmt( os, "%s", b ? "true" : "false" );
    32                 return os;
    33         } // ?|?
    34 
    35         ostype & ?|?( ostype & os, char ch ) {
    36                 fmt( os, "%c", ch );
    37                 if ( ch == '\n' ) setNL( os, true );
     28forall( dtype ostype | ostream( ostype ) )
     29ostype & ?|?( ostype & os, _Bool b ) {
     30        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     31        fmt( os, "%s", b ? "true" : "false" );
     32        return os;
     33} // ?|?
     34
     35forall( dtype ostype | ostream( ostype ) )
     36ostype & ?|?( ostype & os, char ch ) {
     37        fmt( os, "%c", ch );
     38        if ( ch == '\n' ) setNL( os, true );
     39        sepOff( os );
     40        return os;
     41} // ?|?
     42
     43forall( dtype ostype | ostream( ostype ) )
     44ostype & ?|?( ostype & os, signed char c ) {
     45        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     46        fmt( os, "%hhd", c );
     47        return os;
     48} // ?|?
     49
     50forall( dtype ostype | ostream( ostype ) )
     51ostype & ?|?( ostype & os, unsigned char c ) {
     52        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     53        fmt( os, "%hhu", c );
     54        return os;
     55} // ?|?
     56
     57forall( dtype ostype | ostream( ostype ) )
     58ostype & ?|?( ostype & os, short int si ) {
     59        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     60        fmt( os, "%hd", si );
     61        return os;
     62} // ?|?
     63
     64forall( dtype ostype | ostream( ostype ) )
     65ostype & ?|?( ostype & os, unsigned short int usi ) {
     66        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     67        fmt( os, "%hu", usi );
     68        return os;
     69} // ?|?
     70
     71forall( dtype ostype | ostream( ostype ) )
     72ostype & ?|?( ostype & os, int i ) {
     73        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     74        fmt( os, "%d", i );
     75        return os;
     76} // ?|?
     77
     78forall( dtype ostype | ostream( ostype ) )
     79ostype & ?|?( ostype & os, unsigned int ui ) {
     80        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     81        fmt( os, "%u", ui );
     82        return os;
     83} // ?|?
     84
     85forall( dtype ostype | ostream( ostype ) )
     86ostype & ?|?( ostype & os, long int li ) {
     87        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     88        fmt( os, "%ld", li );
     89        return os;
     90} // ?|?
     91
     92forall( dtype ostype | ostream( ostype ) )
     93ostype & ?|?( ostype & os, unsigned long int uli ) {
     94        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     95        fmt( os, "%lu", uli );
     96        return os;
     97} // ?|?
     98
     99forall( dtype ostype | ostream( ostype ) )
     100ostype & ?|?( ostype & os, long long int lli ) {
     101        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     102        fmt( os, "%lld", lli );
     103        return os;
     104} // ?|?
     105
     106forall( dtype ostype | ostream( ostype ) )
     107ostype & ?|?( ostype & os, unsigned long long int ulli ) {
     108        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     109        fmt( os, "%llu", ulli );
     110        return os;
     111} // ?|?
     112
     113forall( dtype ostype | ostream( ostype ) )
     114ostype & ?|?( ostype & os, float f ) {
     115        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     116        fmt( os, "%g", f );
     117        return os;
     118} // ?|?
     119
     120forall( dtype ostype | ostream( ostype ) )
     121ostype & ?|?( ostype & os, double d ) {
     122        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     123        fmt( os, "%.*lg", DBL_DIG, d );
     124        return os;
     125} // ?|?
     126
     127forall( dtype ostype | ostream( ostype ) )
     128ostype & ?|?( ostype & os, long double ld ) {
     129        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     130        fmt( os, "%.*Lg", LDBL_DIG, ld );
     131        return os;
     132} // ?|?
     133
     134forall( dtype ostype | ostream( ostype ) )
     135ostype & ?|?( ostype & os, float _Complex fc ) {
     136        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     137        fmt( os, "%g%+gi", crealf( fc ), cimagf( fc ) );
     138        return os;
     139} // ?|?
     140
     141forall( dtype ostype | ostream( ostype ) )
     142ostype & ?|?( ostype & os, double _Complex dc ) {
     143        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     144        fmt( os, "%.*lg%+.*lgi", DBL_DIG, creal( dc ), DBL_DIG, cimag( dc ) );
     145        return os;
     146} // ?|?
     147
     148forall( dtype ostype | ostream( ostype ) )
     149ostype & ?|?( ostype & os, long double _Complex ldc ) {
     150        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     151        fmt( os, "%.*Lg%+.*Lgi", LDBL_DIG, creall( ldc ), LDBL_DIG, cimagl( ldc ) );
     152        return os;
     153} // ?|?
     154
     155forall( dtype ostype | ostream( ostype ) )
     156ostype & ?|?( ostype & os, const char * str ) {
     157        enum { Open = 1, Close, OpenClose };
     158        static const unsigned char mask[256] @= {
     159                // opening delimiters, no space after
     160                ['('] : Open, ['['] : Open, ['{'] : Open,
     161                ['='] : Open, ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open,
     162                [(unsigned char)'¡'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
     163                // closing delimiters, no space before
     164                [','] : Close, ['.'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
     165                ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
     166                [')'] : Close, [']'] : Close, ['}'] : Close,
     167                // opening-closing delimiters, no space before or after
     168                ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose, [':'] : OpenClose,
     169                [' '] : OpenClose, ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
     170        }; // mask
     171
     172  if ( str[0] == '\0' ) { sepOff( os ); return os; }            // null string => no separator
     173
     174        // first character IS NOT spacing or closing punctuation => add left separator
     175        unsigned char ch = str[0];                                                      // must make unsigned
     176        if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
     177                fmt( os, "%s", sepGetCur( os ) );
     178        } // if
     179
     180        // if string starts line, must reset to determine open state because separator is off
     181        sepReset( os );                                                                         // reset separator
     182
     183        // last character IS spacing or opening punctuation => turn off separator for next item
     184        size_t len = strlen( str );
     185        ch = str[len - 1];                                                                      // must make unsigned
     186        if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
     187                sepOn( os );
     188        } else {
    38189                sepOff( os );
    39                 return os;
    40         } // ?|?
    41 
    42         ostype & ?|?( ostype & os, signed char c ) {
    43                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    44                 fmt( os, "%hhd", c );
    45                 return os;
    46         } // ?|?
    47 
    48         ostype & ?|?( ostype & os, unsigned char c ) {
    49                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    50                 fmt( os, "%hhu", c );
    51                 return os;
    52         } // ?|?
    53 
    54         ostype & ?|?( ostype & os, short int si ) {
    55                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    56                 fmt( os, "%hd", si );
    57                 return os;
    58         } // ?|?
    59 
    60         ostype & ?|?( ostype & os, unsigned short int usi ) {
    61                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    62                 fmt( os, "%hu", usi );
    63                 return os;
    64         } // ?|?
    65 
    66         ostype & ?|?( ostype & os, int i ) {
    67                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    68                 fmt( os, "%d", i );
    69                 return os;
    70         } // ?|?
    71 
    72         ostype & ?|?( ostype & os, unsigned int ui ) {
    73                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    74                 fmt( os, "%u", ui );
    75                 return os;
    76         } // ?|?
    77 
    78         ostype & ?|?( ostype & os, long int li ) {
    79                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    80                 fmt( os, "%ld", li );
    81                 return os;
    82         } // ?|?
    83 
    84         ostype & ?|?( ostype & os, unsigned long int uli ) {
    85                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    86                 fmt( os, "%lu", uli );
    87                 return os;
    88         } // ?|?
    89 
    90         ostype & ?|?( ostype & os, long long int lli ) {
    91                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    92                 fmt( os, "%lld", lli );
    93                 return os;
    94         } // ?|?
    95 
    96         ostype & ?|?( ostype & os, unsigned long long int ulli ) {
    97                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    98                 fmt( os, "%llu", ulli );
    99                 return os;
    100         } // ?|?
    101 
    102         ostype & ?|?( ostype & os, float f ) {
    103                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    104                 fmt( os, "%g", f );
    105                 return os;
    106         } // ?|?
    107 
    108         ostype & ?|?( ostype & os, double d ) {
    109                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    110                 fmt( os, "%.*lg", DBL_DIG, d );
    111                 return os;
    112         } // ?|?
    113 
    114         ostype & ?|?( ostype & os, long double ld ) {
    115                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    116                 fmt( os, "%.*Lg", LDBL_DIG, ld );
    117                 return os;
    118         } // ?|?
    119 
    120         ostype & ?|?( ostype & os, float _Complex fc ) {
    121                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    122                 fmt( os, "%g%+gi", crealf( fc ), cimagf( fc ) );
    123                 return os;
    124         } // ?|?
    125 
    126         ostype & ?|?( ostype & os, double _Complex dc ) {
    127                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    128                 fmt( os, "%.*lg%+.*lgi", DBL_DIG, creal( dc ), DBL_DIG, cimag( dc ) );
    129                 return os;
    130         } // ?|?
    131 
    132         ostype & ?|?( ostype & os, long double _Complex ldc ) {
    133                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    134                 fmt( os, "%.*Lg%+.*Lgi", LDBL_DIG, creall( ldc ), LDBL_DIG, cimagl( ldc ) );
    135                 return os;
    136         } // ?|?
    137 
    138         ostype & ?|?( ostype & os, const char * str ) {
    139                 enum { Open = 1, Close, OpenClose };
    140                 static const unsigned char mask[256] @= {
    141                         // opening delimiters, no space after
    142                         ['('] : Open, ['['] : Open, ['{'] : Open,
    143                         ['='] : Open, ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open,
    144                         [(unsigned char)'¡'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
    145                         // closing delimiters, no space before
    146                         [','] : Close, ['.'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
    147                         ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
    148                         [')'] : Close, [']'] : Close, ['}'] : Close,
    149                         // opening-closing delimiters, no space before or after
    150                         ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose, [':'] : OpenClose,
    151                         [' '] : OpenClose, ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
    152                 }; // mask
    153 
    154           if ( str[0] == '\0' ) { sepOff( os ); return os; } // null string => no separator
    155 
    156                 // first character IS NOT spacing or closing punctuation => add left separator
    157                 unsigned char ch = str[0];                                              // must make unsigned
    158                 if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
    159                         fmt( os, "%s", sepGetCur( os ) );
    160                 } // if
    161 
    162                 // if string starts line, must reset to determine open state because separator is off
    163                 sepReset( os );                                                                 // reset separator
    164 
    165                 // last character IS spacing or opening punctuation => turn off separator for next item
    166                 size_t len = strlen( str );
    167                 ch = str[len - 1];                                                              // must make unsigned
    168                 if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
    169                         sepOn( os );
    170                 } else {
    171                         sepOff( os );
    172                 } // if
    173                 if ( ch == '\n' ) setNL( os, true );                    // check *AFTER* sepPrt call above as it resets NL flag
    174                 return write( os, str, len );
    175         } // ?|?
    176 
    177 //      ostype & ?|?( ostype & os, const char16_t * str ) {
    178 //              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    179 //              fmt( os, "%ls", str );
    180 //              return os;
    181 //      } // ?|?
     190        } // if
     191        if ( ch == '\n' ) setNL( os, true );                            // check *AFTER* sepPrt call above as it resets NL flag
     192        return write( os, str, len );
     193} // ?|?
     194
     195// forall( dtype ostype | ostream( ostype ) )
     196// ostype & ?|?( ostype & os, const char16_t * str ) {
     197//      if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     198//      fmt( os, "%ls", str );
     199//      return os;
     200// } // ?|?
    182201
    183202// #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
    184 //      ostype & ?|?( ostype & os, const char32_t * str ) {
    185 //              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    186 //              fmt( os, "%ls", str );
    187 //              return os;
    188 //      } // ?|?
     203// forall( dtype ostype | ostream( ostype ) )
     204// ostype & ?|?( ostype & os, const char32_t * str ) {
     205//      if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     206//      fmt( os, "%ls", str );
     207//      return os;
     208// } // ?|?
    189209// #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
    190210
    191 //      ostype & ?|?( ostype & os, const wchar_t * str ) {
    192 //              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    193 //              fmt( os, "%ls", str );
    194 //              return os;
    195 //      } // ?|?
    196 
    197         ostype & ?|?( ostype & os, const void * p ) {
    198                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    199                 fmt( os, "%p", p );
    200                 return os;
    201         } // ?|?
    202 
    203 
    204         // manipulators
    205         ostype & ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
    206                 return manip( os );
    207         } // ?|?
    208 
    209         ostype & sep( ostype & os ) {
    210                 os | sepGet( os );
    211                 return os;
    212         } // sep
    213 
    214         ostype & sepTuple( ostype & os ) {
    215                 os | sepGetTuple( os );
    216                 return os;
    217         } // sepTuple
    218 
    219         ostype & endl( ostype & os ) {
    220                 os | '\n';
    221                 setNL( os, true );
    222                 flush( os );
    223                 sepOff( os );                                                                   // prepare for next line
    224                 return os;
    225         } // endl
    226 
    227         ostype & sepOn( ostype & os ) {
    228                 sepOn( os );
    229                 return os;
    230         } // sepOn
    231 
    232         ostype & sepOff( ostype & os ) {
    233                 sepOff( os );
    234                 return os;
    235         } // sepOff
    236 
    237         ostype & sepEnable( ostype & os ) {
    238                 sepEnable( os );
    239                 return os;
    240         } // sepEnable
    241 
    242         ostype & sepDisable( ostype & os ) {
    243                 sepDisable( os );
    244                 return os;
    245         } // sepDisable
    246 } // distribution
     211// forall( dtype ostype | ostream( ostype ) )
     212// ostype & ?|?( ostype & os, const wchar_t * str ) {
     213//      if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     214//      fmt( os, "%ls", str );
     215//      return os;
     216// } // ?|?
     217
     218forall( dtype ostype | ostream( ostype ) )
     219ostype & ?|?( ostype & os, const void * p ) {
     220        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     221        fmt( os, "%p", p );
     222        return os;
     223} // ?|?
    247224
    248225
    … …  
    257234} // ?|?
    258235
     236
     237// manipulators
     238forall( dtype ostype | ostream( ostype ) )
     239ostype & ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
     240        return manip( os );
     241} // ?|?
     242
     243forall( dtype ostype | ostream( ostype ) )
     244ostype & sep( ostype & os ) {
     245        os | sepGet( os );
     246        return os;
     247} // sep
     248
     249forall( dtype ostype | ostream( ostype ) )
     250ostype & sepTuple( ostype & os ) {
     251        os | sepGetTuple( os );
     252        return os;
     253} // sepTuple
     254
     255forall( dtype ostype | ostream( ostype ) )
     256ostype & endl( ostype & os ) {
     257        os | '\n';
     258        setNL( os, true );
     259        flush( os );
     260        sepOff( os );                                                                           // prepare for next line
     261        return os;
     262} // endl
     263
     264forall( dtype ostype | ostream( ostype ) )
     265ostype & sepOn( ostype & os ) {
     266        sepOn( os );
     267        return os;
     268} // sepOn
     269
     270forall( dtype ostype | ostream( ostype ) )
     271ostype & sepOff( ostype & os ) {
     272        sepOff( os );
     273        return os;
     274} // sepOff
     275
     276forall( dtype ostype | ostream( ostype ) )
     277ostype & sepEnable( ostype & os ) {
     278        sepEnable( os );
     279        return os;
     280} // sepEnable
     281
     282forall( dtype ostype | ostream( ostype ) )
     283ostype & sepDisable( ostype & os ) {
     284        sepDisable( os );
     285        return os;
     286} // sepDisable
     287
    259288//---------------------------------------
    260289
    261 // writes the range [begin, end) to the given stream
    262290forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
    263291void write( iterator_type begin, iterator_type end, ostype & os ) {
    … …  
    274302//---------------------------------------
    275303
    276 forall( dtype istype | istream( istype ) ) {
    277         istype & ?|?( istype & is, _Bool & b ) {
    278                 char val[6];
    279                 fmt( is, "%5s", val );
    280                 if ( strcmp( val, "true" ) == 0 ) b = true;
    281                 else if ( strcmp( val, "false" ) == 0 ) b = false;
    282                 else {
    283                         fprintf( stderr, "invalid _Bool constant\n" );
    284                         abort();
    285                 } // if
    286                 return is;
    287         } // ?|?
    288 
    289         istype & ?|?( istype & is, char & c ) {
    290                 fmt( is, "%c", &c );                                                    // must pass pointer through varg to fmt
    291                 return is;
    292         } // ?|?
    293 
    294         istype & ?|?( istype & is, signed char & sc ) {
    295                 fmt( is, "%hhd", &sc );
    296                 return is;
    297         } // ?|?
    298 
    299         istype & ?|?( istype & is, unsigned char & usc ) {
    300                 fmt( is, "%hhu", &usc );
    301                 return is;
    302         } // ?|?
    303 
    304         istype & ?|?( istype & is, short int & si ) {
    305                 fmt( is, "%hd", &si );
    306                 return is;
    307         } // ?|?
    308 
    309         istype & ?|?( istype & is, unsigned short int & usi ) {
    310                 fmt( is, "%hu", &usi );
    311                 return is;
    312         } // ?|?
    313 
    314         istype & ?|?( istype & is, int & i ) {
    315                 fmt( is, "%d", &i );
    316                 return is;
    317         } // ?|?
    318 
    319         istype & ?|?( istype & is, unsigned int & ui ) {
    320                 fmt( is, "%u", &ui );
    321                 return is;
    322         } // ?|?
    323 
    324         istype & ?|?( istype & is, long int & li ) {
    325                 fmt( is, "%ld", &li );
    326                 return is;
    327         } // ?|?
    328 
    329         istype & ?|?( istype & is, unsigned long int & ulli ) {
    330                 fmt( is, "%lu", &ulli );
    331                 return is;
    332         } // ?|?
    333 
    334         istype & ?|?( istype & is, long long int & lli ) {
    335                 fmt( is, "%lld", &lli );
    336                 return is;
    337         } // ?|?
    338 
    339         istype & ?|?( istype & is, unsigned long long int & ulli ) {
    340                 fmt( is, "%llu", &ulli );
    341                 return is;
    342         } // ?|?
    343 
    344 
    345         istype & ?|?( istype & is, float & f ) {
    346                 fmt( is, "%f", &f );
    347                 return is;
    348         } // ?|?
    349 
    350         istype & ?|?( istype & is, double & d ) {
    351                 fmt( is, "%lf", &d );
    352                 return is;
    353         } // ?|?
    354 
    355         istype & ?|?( istype & is, long double & ld ) {
    356                 fmt( is, "%Lf", &ld );
    357                 return is;
    358         } // ?|?
    359 
    360 
    361         istype & ?|?( istype & is, float _Complex & fc ) {
    362                 float re, im;
    363                 fmt( is, "%g%gi", &re, &im );
    364                 fc = re + im * _Complex_I;
    365                 return is;
    366         } // ?|?
    367 
    368         istype & ?|?( istype & is, double _Complex & dc ) {
    369                 double re, im;
    370                 fmt( is, "%lf%lfi", &re, &im );
    371                 dc = re + im * _Complex_I;
    372                 return is;
    373         } // ?|?
    374 
    375         istype & ?|?( istype & is, long double _Complex & ldc ) {
    376                 long double re, im;
    377                 fmt( is, "%Lf%Lfi", &re, &im );
    378                 ldc = re + im * _Complex_I;
    379                 return is;
    380         } // ?|?
    381 
    382 
    383         // manipulators
    384         istype & ?|?( istype & is, istype & (* manip)( istype & ) ) {
    385                 return manip( is );
    386         } // ?|?
    387 
    388         istype & endl( istype & is ) {
    389                 fmt( is, "%*[ \t\f\n\r\v]" );                                   // ignore whitespace
    390                 return is;
    391         } // endl
    392 } // distribution
     304forall( dtype istype | istream( istype ) )
     305istype & ?|?( 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
     317forall( dtype istype | istream( istype ) )
     318istype & ?|?( istype & is, char & c ) {
     319        fmt( is, "%c", &c );                                                            // must pass pointer through varg to fmt
     320        return is;
     321} // ?|?
     322
     323forall( dtype istype | istream( istype ) )
     324istype & ?|?( istype & is, signed char & sc ) {
     325        fmt( is, "%hhd", &sc );
     326        return is;
     327} // ?|?
     328
     329forall( dtype istype | istream( istype ) )
     330istype & ?|?( istype & is, unsigned char & usc ) {
     331        fmt( is, "%hhu", &usc );
     332        return is;
     333} // ?|?
     334
     335forall( dtype istype | istream( istype ) )
     336istype & ?|?( istype & is, short int & si ) {
     337        fmt( is, "%hd", &si );
     338        return is;
     339} // ?|?
     340
     341forall( dtype istype | istream( istype ) )
     342istype & ?|?( istype & is, unsigned short int & usi ) {
     343        fmt( is, "%hu", &usi );
     344        return is;
     345} // ?|?
     346
     347forall( dtype istype | istream( istype ) )
     348istype & ?|?( istype & is, int & i ) {
     349        fmt( is, "%d", &i );
     350        return is;
     351} // ?|?
     352
     353forall( dtype istype | istream( istype ) )
     354istype & ?|?( istype & is, unsigned int & ui ) {
     355        fmt( is, "%u", &ui );
     356        return is;
     357} // ?|?
     358
     359forall( dtype istype | istream( istype ) )
     360istype & ?|?( istype & is, long int & li ) {
     361        fmt( is, "%ld", &li );
     362        return is;
     363} // ?|?
     364
     365forall( dtype istype | istream( istype ) )
     366istype & ?|?( istype & is, unsigned long int & ulli ) {
     367        fmt( is, "%lu", &ulli );
     368        return is;
     369} // ?|?
     370
     371forall( dtype istype | istream( istype ) )
     372istype & ?|?( istype & is, long long int & lli ) {
     373        fmt( is, "%lld", &lli );
     374        return is;
     375} // ?|?
     376
     377forall( dtype istype | istream( istype ) )
     378istype & ?|?( istype & is, unsigned long long int & ulli ) {
     379        fmt( is, "%llu", &ulli );
     380        return is;
     381} // ?|?
     382
     383
     384forall( dtype istype | istream( istype ) )
     385istype & ?|?( istype & is, float & f ) {
     386        fmt( is, "%f", &f );
     387        return is;
     388} // ?|?
     389
     390forall( dtype istype | istream( istype ) )
     391istype & ?|?( istype & is, double & d ) {
     392        fmt( is, "%lf", &d );
     393        return is;
     394} // ?|?
     395
     396forall( dtype istype | istream( istype ) )
     397istype & ?|?( istype & is, long double & ld ) {
     398        fmt( is, "%Lf", &ld );
     399        return is;
     400} // ?|?
     401
     402
     403forall( dtype istype | istream( istype ) )
     404istype & ?|?( istype & is, float _Complex & fc ) {
     405        float re, im;
     406        fmt( is, "%g%gi", &re, &im );
     407        fc = re + im * _Complex_I;
     408        return is;
     409} // ?|?
     410
     411forall( dtype istype | istream( istype ) )
     412istype & ?|?( istype & is, double _Complex & dc ) {
     413        double re, im;
     414        fmt( is, "%lf%lfi", &re, &im );
     415        dc = re + im * _Complex_I;
     416        return is;
     417} // ?|?
     418
     419forall( dtype istype | istream( istype ) )
     420istype & ?|?( istype & is, long double _Complex & ldc ) {
     421        long double re, im;
     422        fmt( is, "%Lf%Lfi", &re, &im );
     423        ldc = re + im * _Complex_I;
     424        return is;
     425} // ?|?
     426
     427forall( dtype istype | istream( istype ) )
     428istype & ?|?( istype & is, istype & (* manip)( istype & ) ) {
     429        return manip( is );
     430} // ?|?
     431
     432forall( dtype istype | istream( istype ) )
     433istype & endl( istype & is ) {
     434        fmt( is, "%*[ \t\f\n\r\v]" );                                           // ignore whitespace
     435        return is;
     436} // endl
    393437
    394438_Istream_cstrUC cstr( char * str ) { return (_Istream_cstrUC){ str }; }

  • src/libcfa/rational

    r249d6e6 r863c413  
    1212// Created On       : Wed Apr  6 17:56:25 2016
    1313// Last Modified By : Peter A. Buhr
    14 // Last Modified On : Sat Jun  2 09:10:01 2018
    15 // Update Count     : 105
     14// Last Modified On : Wed Dec  6 23:12:53 2017
     15// Update Count     : 97
    1616//
    1717
    … …  
    4646// implementation
    4747
    48 forall( otype RationalImpl | arithmetic( RationalImpl ) ) {
    49         struct Rational {
    50                 RationalImpl numerator, denominator;                    // invariant: denominator > 0
    51         }; // Rational
     48forall( otype RationalImpl | arithmetic( RationalImpl ) )
     49struct Rational {
     50        RationalImpl numerator, denominator;                            // invariant: denominator > 0
     51}; // Rational
    5252
    53         // constructors
     53// constructors
    5454
    55         void ?{}( Rational(RationalImpl) & r );
    56         void ?{}( Rational(RationalImpl) & r, RationalImpl n );
    57         void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d );
    58         void ?{}( Rational(RationalImpl) & r, zero_t );
    59         void ?{}( Rational(RationalImpl) & r, one_t );
     55forall( otype RationalImpl | arithmetic( RationalImpl ) )
     56void ?{}( Rational(RationalImpl) & r );
    6057
    61         // numerator/denominator getter
     58forall( otype RationalImpl | arithmetic( RationalImpl ) )
     59void ?{}( Rational(RationalImpl) & r, RationalImpl n );
    6260
    63         RationalImpl numerator( Rational(RationalImpl) r );
    64         RationalImpl denominator( Rational(RationalImpl) r );
    65         [ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src );
     61forall( otype RationalImpl | arithmetic( RationalImpl ) )
     62void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d );
    6663
    67         // numerator/denominator setter
     64forall( otype RationalImpl | arithmetic( RationalImpl ) )
     65void ?{}( Rational(RationalImpl) & r, zero_t );
    6866
    69         RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n );
    70         RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d );
     67forall( otype RationalImpl | arithmetic( RationalImpl ) )
     68void ?{}( Rational(RationalImpl) & r, one_t );
    7169
    72         // comparison
     70// numerator/denominator getter
    7371
    74         int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    75         int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    76         int ?<?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    77         int ?<=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    78         int ?>?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    79         int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     72forall( otype RationalImpl | arithmetic( RationalImpl ) )
     73RationalImpl numerator( Rational(RationalImpl) r );
    8074
    81         // arithmetic
     75forall( otype RationalImpl | arithmetic( RationalImpl ) )
     76RationalImpl denominator( Rational(RationalImpl) r );
    8277
    83         Rational(RationalImpl) +?( Rational(RationalImpl) r );
    84         Rational(RationalImpl) -?( Rational(RationalImpl) r );
    85         Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    86         Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    87         Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    88         Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     78forall( otype RationalImpl | arithmetic( RationalImpl ) )
     79[ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src );
    8980
    90         // I/O
    91         forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } )
    92         istype & ?|?( istype &, Rational(RationalImpl) & );
     81// numerator/denominator setter
    9382
    94         forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } )
    95         ostype & ?|?( ostype &, Rational(RationalImpl ) );
    96 } // distribution
     83forall( otype RationalImpl | arithmetic( RationalImpl ) )
     84RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n );
     85
     86forall( otype RationalImpl | arithmetic( RationalImpl ) )
     87RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d );
     88
     89// comparison
     90
     91forall( otype RationalImpl | arithmetic( RationalImpl ) )
     92int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     93
     94forall( otype RationalImpl | arithmetic( RationalImpl ) )
     95int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     96
     97forall( otype RationalImpl | arithmetic( RationalImpl ) )
     98int ?<?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     99
     100forall( otype RationalImpl | arithmetic( RationalImpl ) )
     101int ?<=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     102
     103forall( otype RationalImpl | arithmetic( RationalImpl ) )
     104int ?>?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     105
     106forall( otype RationalImpl | arithmetic( RationalImpl ) )
     107int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     108
     109// arithmetic
     110
     111forall( otype RationalImpl | arithmetic( RationalImpl ) )
     112Rational(RationalImpl) +?( Rational(RationalImpl) r );
     113
     114forall( otype RationalImpl | arithmetic( RationalImpl ) )
     115Rational(RationalImpl) -?( Rational(RationalImpl) r );
     116
     117forall( otype RationalImpl | arithmetic( RationalImpl ) )
     118Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     119
     120forall( otype RationalImpl | arithmetic( RationalImpl ) )
     121Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     122
     123forall( otype RationalImpl | arithmetic( RationalImpl ) )
     124Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     125
     126forall( otype RationalImpl | arithmetic( RationalImpl ) )
     127Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    97128
    98129// conversion
    … …  
    102133Rational(RationalImpl) narrow( double f, RationalImpl md );
    103134
     135// I/O
     136forall( otype RationalImpl | arithmetic( RationalImpl ) )
     137forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } )
     138istype & ?|?( istype &, Rational(RationalImpl) & );
     139
     140forall( otype RationalImpl | arithmetic( RationalImpl ) )
     141forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } )
     142ostype & ?|?( ostype &, Rational(RationalImpl ) );
     143
    104144// Local Variables: //
    105145// mode: c //

  • src/libcfa/rational.c

    r249d6e6 r863c413  
    1010// Created On       : Wed Apr  6 17:54:28 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  2 09:24:33 2018
    13 // Update Count     : 162
     12// Last Modified On : Wed Dec  6 23:13:58 2017
     13// Update Count     : 156
    1414//
    1515
    … …  
    1818#include "stdlib"
    1919
    20 forall( otype RationalImpl | arithmetic( RationalImpl ) ) {
    21         // helper routines
    22 
    23         // Calculate greatest common denominator of two numbers, the first of which may be negative. Used to reduce
    24         // rationals.  alternative: https://en.wikipedia.org/wiki/Binary_GCD_algorithm
    25         static RationalImpl gcd( RationalImpl a, RationalImpl b ) {
    26                 for ( ;; ) {                                                                    // Euclid's algorithm
    27                         RationalImpl r = a % b;
    28                   if ( r == (RationalImpl){0} ) break;
    29                         a = b;
    30                         b = r;
    31                 } // for
    32                 return b;
    33         } // gcd
    34 
    35         static RationalImpl simplify( RationalImpl & n, RationalImpl & d ) {
    36                 if ( d == (RationalImpl){0} ) {
    37                         serr | "Invalid rational number construction: denominator cannot be equal to 0." | endl;
    38                         exit( EXIT_FAILURE );
    39                 } // exit
    40                 if ( d < (RationalImpl){0} ) { d = -d; n = -n; } // move sign to numerator
    41                 return gcd( abs( n ), d );                                              // simplify
    42         } // Rationalnumber::simplify
    43 
    44         // constructors
    45 
    46         void ?{}( Rational(RationalImpl) & r ) {
    47                 r{ (RationalImpl){0}, (RationalImpl){1} };
    48         } // rational
    49 
    50         void ?{}( Rational(RationalImpl) & r, RationalImpl n ) {
    51                 r{ n, (RationalImpl){1} };
    52         } // rational
    53 
    54         void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) {
    55                 RationalImpl t = simplify( n, d );                              // simplify
    56                 r.numerator = n / t;
    57                 r.denominator = d / t;
    58         } // rational
    59 
    60 
    61         // getter for numerator/denominator
    62 
    63         RationalImpl numerator( Rational(RationalImpl) r ) {
    64                 return r.numerator;
    65         } // numerator
    66 
    67         RationalImpl denominator( Rational(RationalImpl) r ) {
    68                 return r.denominator;
    69         } // denominator
    70 
    71         [ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ) {
    72                 return dest = src.[ numerator, denominator ];
    73         } // ?=?
    74 
    75         // setter for numerator/denominator
    76 
    77         RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n ) {
    78                 RationalImpl prev = r.numerator;
    79                 RationalImpl t = gcd( abs( n ), r.denominator ); // simplify
    80                 r.numerator = n / t;
    81                 r.denominator = r.denominator / t;
    82                 return prev;
    83         } // numerator
    84 
    85         RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d ) {
    86                 RationalImpl prev = r.denominator;
    87                 RationalImpl t = simplify( r.numerator, d );    // simplify
    88                 r.numerator = r.numerator / t;
    89                 r.denominator = d / t;
    90                 return prev;
    91         } // denominator
    92 
    93         // comparison
    94 
    95         int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    96                 return l.numerator * r.denominator == l.denominator * r.numerator;
    97         } // ?==?
    98 
    99         int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    100                 return ! ( l == r );
    101         } // ?!=?
    102 
    103         int ?<?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    104                 return l.numerator * r.denominator < l.denominator * r.numerator;
    105         } // ?<?
    106 
    107         int ?<=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    108                 return l.numerator * r.denominator <= l.denominator * r.numerator;
    109         } // ?<=?
    110 
    111         int ?>?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    112                 return ! ( l <= r );
    113         } // ?>?
    114 
    115         int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    116                 return ! ( l < r );
    117         } // ?>=?
    118 
    119         // arithmetic
    120 
    121         Rational(RationalImpl) +?( Rational(RationalImpl) r ) {
    122                 Rational(RationalImpl) t = { r.numerator, r.denominator };
    123                 return t;
    124         } // +?
    125 
    126         Rational(RationalImpl) -?( Rational(RationalImpl) r ) {
    127                 Rational(RationalImpl) t = { -r.numerator, r.denominator };
    128                 return t;
    129         } // -?
    130 
    131         Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    132                 if ( l.denominator == r.denominator ) {                 // special case
    133                         Rational(RationalImpl) t = { l.numerator + r.numerator, l.denominator };
    134                         return t;
    135                 } else {
    136                         Rational(RationalImpl) t = { l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator };
    137                         return t;
    138                 } // if
    139         } // ?+?
    140 
    141         Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    142                 if ( l.denominator == r.denominator ) {                 // special case
    143                         Rational(RationalImpl) t = { l.numerator - r.numerator, l.denominator };
    144                         return t;
    145                 } else {
    146                         Rational(RationalImpl) t = { l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator };
    147                         return t;
    148                 } // if
    149         } // ?-?
    150 
    151         Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    152                 Rational(RationalImpl) t = { l.numerator * r.numerator, l.denominator * r.denominator };
    153                 return t;
    154         } // ?*?
    155 
    156         Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    157                 if ( r.numerator < (RationalImpl){0} ) {
    158                         r.numerator = -r.numerator;
    159                         r.denominator = -r.denominator;
    160                 } // if
    161                 Rational(RationalImpl) t = { l.numerator * r.denominator, l.denominator * r.numerator };
    162                 return t;
    163         } // ?/?
    164 
    165         // I/O
    166 
    167         forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } )
    168         istype & ?|?( istype & is, Rational(RationalImpl) & r ) {
    169                 RationalImpl t;
    170                 is | r.numerator | r.denominator;
    171                 t = simplify( r.numerator, r.denominator );
    172                 r.numerator /= t;
    173                 r.denominator /= t;
    174                 return is;
    175         } // ?|?
    176 
    177         forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } )
    178         ostype & ?|?( ostype & os, Rational(RationalImpl ) r ) {
    179                 return os | r.numerator | '/' | r.denominator;
    180         } // ?|?
    181 } // distribution
     20// helper routines
     21
     22// Calculate greatest common denominator of two numbers, the first of which may be negative. Used to reduce rationals.
     23// alternative: https://en.wikipedia.org/wiki/Binary_GCD_algorithm
     24forall( otype RationalImpl | arithmetic( RationalImpl ) )
     25static RationalImpl gcd( RationalImpl a, RationalImpl b ) {
     26        for ( ;; ) {                                                                            // Euclid's algorithm
     27                RationalImpl r = a % b;
     28          if ( r == (RationalImpl){0} ) break;
     29                a = b;
     30                b = r;
     31        } // for
     32        return b;
     33} // gcd
     34
     35forall( otype RationalImpl | arithmetic( RationalImpl ) )
     36static RationalImpl simplify( RationalImpl & n, RationalImpl & d ) {
     37        if ( d == (RationalImpl){0} ) {
     38                serr | "Invalid rational number construction: denominator cannot be equal to 0." | endl;
     39                exit( EXIT_FAILURE );
     40        } // exit
     41        if ( d < (RationalImpl){0} ) { d = -d; n = -n; }        // move sign to numerator
     42        return gcd( abs( n ), d );                                                      // simplify
     43} // Rationalnumber::simplify
     44
     45
     46// constructors
     47
     48forall( otype RationalImpl | arithmetic( RationalImpl ) )
     49void ?{}( Rational(RationalImpl) & r ) {
     50        r{ (RationalImpl){0}, (RationalImpl){1} };
     51} // rational
     52
     53forall( otype RationalImpl | arithmetic( RationalImpl ) )
     54void ?{}( Rational(RationalImpl) & r, RationalImpl n ) {
     55        r{ n, (RationalImpl){1} };
     56} // rational
     57
     58forall( otype RationalImpl | arithmetic( RationalImpl ) )
     59void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) {
     60        RationalImpl t = simplify( n, d );                                      // simplify
     61        r.numerator = n / t;
     62        r.denominator = d / t;
     63} // rational
     64
     65
     66// getter for numerator/denominator
     67
     68forall( otype RationalImpl | arithmetic( RationalImpl ) )
     69RationalImpl numerator( Rational(RationalImpl) r ) {
     70        return r.numerator;
     71} // numerator
     72
     73forall( otype RationalImpl | arithmetic( RationalImpl ) )
     74RationalImpl denominator( Rational(RationalImpl) r ) {
     75        return r.denominator;
     76} // denominator
     77
     78forall( otype RationalImpl | arithmetic( RationalImpl ) )
     79[ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ) {
     80        return dest = src.[ numerator, denominator ];
     81}
     82
     83// setter for numerator/denominator
     84
     85forall( otype RationalImpl | arithmetic( RationalImpl ) )
     86RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n ) {
     87        RationalImpl prev = r.numerator;
     88        RationalImpl t = gcd( abs( n ), r.denominator );                // simplify
     89        r.numerator = n / t;
     90        r.denominator = r.denominator / t;
     91        return prev;
     92} // numerator
     93
     94forall( otype RationalImpl | arithmetic( RationalImpl ) )
     95RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d ) {
     96        RationalImpl prev = r.denominator;
     97        RationalImpl t = simplify( r.numerator, d );                    // simplify
     98        r.numerator = r.numerator / t;
     99        r.denominator = d / t;
     100        return prev;
     101} // denominator
     102
     103
     104// comparison
     105
     106forall( otype RationalImpl | arithmetic( RationalImpl ) )
     107int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     108        return l.numerator * r.denominator == l.denominator * r.numerator;
     109} // ?==?
     110
     111forall( otype RationalImpl | arithmetic( RationalImpl ) )
     112int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     113        return ! ( l == r );
     114} // ?!=?
     115
     116forall( otype RationalImpl | arithmetic( RationalImpl ) )
     117int ?<?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     118        return l.numerator * r.denominator < l.denominator * r.numerator;
     119} // ?<?
     120
     121forall( otype RationalImpl | arithmetic( RationalImpl ) )
     122int ?<=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     123        return l.numerator * r.denominator <= l.denominator * r.numerator;
     124} // ?<=?
     125
     126forall( otype RationalImpl | arithmetic( RationalImpl ) )
     127int ?>?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     128        return ! ( l <= r );
     129} // ?>?
     130
     131forall( otype RationalImpl | arithmetic( RationalImpl ) )
     132int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     133        return ! ( l < r );
     134} // ?>=?
     135
     136
     137// arithmetic
     138
     139forall( otype RationalImpl | arithmetic( RationalImpl ) )
     140Rational(RationalImpl) +?( Rational(RationalImpl) r ) {
     141        Rational(RationalImpl) t = { r.numerator, r.denominator };
     142        return t;
     143} // +?
     144
     145forall( otype RationalImpl | arithmetic( RationalImpl ) )
     146Rational(RationalImpl) -?( Rational(RationalImpl) r ) {
     147        Rational(RationalImpl) t = { -r.numerator, r.denominator };
     148        return t;
     149} // -?
     150
     151forall( otype RationalImpl | arithmetic( RationalImpl ) )
     152Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     153        if ( l.denominator == r.denominator ) {                         // special case
     154                Rational(RationalImpl) t = { l.numerator + r.numerator, l.denominator };
     155                return t;
     156        } else {
     157                Rational(RationalImpl) t = { l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator };
     158                return t;
     159        } // if
     160} // ?+?
     161
     162forall( otype RationalImpl | arithmetic( RationalImpl ) )
     163Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     164        if ( l.denominator == r.denominator ) {                         // special case
     165                Rational(RationalImpl) t = { l.numerator - r.numerator, l.denominator };
     166                return t;
     167        } else {
     168                Rational(RationalImpl) t = { l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator };
     169                return t;
     170        } // if
     171} // ?-?
     172
     173forall( otype RationalImpl | arithmetic( RationalImpl ) )
     174Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     175        Rational(RationalImpl) t = { l.numerator * r.numerator, l.denominator * r.denominator };
     176        return t;
     177} // ?*?
     178
     179forall( otype RationalImpl | arithmetic( RationalImpl ) )
     180Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     181        if ( r.numerator < (RationalImpl){0} ) {
     182                r.numerator = -r.numerator;
     183                r.denominator = -r.denominator;
     184        } // if
     185        Rational(RationalImpl) t = { l.numerator * r.denominator, l.denominator * r.numerator };
     186        return t;
     187} // ?/?
     188
    182189
    183190// conversion
    … …  
    188195} // widen
    189196
     197// http://www.ics.uci.edu/~eppstein/numth/frap.c
    190198forall( otype RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); RationalImpl convert( double ); } )
    191199Rational(RationalImpl) narrow( double f, RationalImpl md ) {
    192         // http://www.ics.uci.edu/~eppstein/numth/frap.c
    193200        if ( md <= (RationalImpl){1} ) {                                        // maximum fractional digits too small?
    194201                return (Rational(RationalImpl)){ convert( f ), (RationalImpl){1}}; // truncate fraction
    … …  
    217224} // narrow
    218225
     226
     227// I/O
     228
     229forall( otype RationalImpl | arithmetic( RationalImpl ) )
     230forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } )
     231istype & ?|?( istype & is, Rational(RationalImpl) & r ) {
     232        RationalImpl t;
     233        is | r.numerator | r.denominator;
     234        t = simplify( r.numerator, r.denominator );
     235        r.numerator /= t;
     236        r.denominator /= t;
     237        return is;
     238} // ?|?
     239
     240forall( otype RationalImpl | arithmetic( RationalImpl ) )
     241forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } )
     242ostype & ?|?( ostype & os, Rational(RationalImpl ) r ) {
     243        return os | r.numerator | '/' | r.denominator;
     244} // ?|?
     245
    219246// Local Variables: //
    220247// tab-width: 4 //

  • src/libcfa/stdlib

    r249d6e6 r863c413  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  2 08:46:35 2018
    13 // Update Count     : 306
     12// Last Modified On : Wed May 16 07:53:10 2018
     13// Update Count     : 300
    1414//
    1515
    1616#pragma once
    1717
    18 #include <stdlib.h>                                                                             // allocation, strto*, *abs
    19 extern "C" {
    20         void * memalign( size_t align, size_t size );
    21         void * aligned_alloc( size_t align, size_t size );
    22         void * memset( void * dest, int c, size_t size );
    23 } // extern "C"
     18#include <stdlib.h>                                                                             // strto*, *abs
    2419
    2520//---------------------------------------
    … …  
    3227//---------------------------------------
    3328
     29// C dynamic allocation
    3430static inline forall( dtype T | sized(T) ) {
    35         // C dynamic allocation
    36 
    3731        T * malloc( void ) {
    3832                // printf( "* malloc\n" );
    … …  
    5751        } // realloc
    5852
     53        extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void *
    5954        T * memalign( size_t align ) {
    6055                //printf( "X4\n" );
    … …  
    6257        } // memalign
    6358
     59        extern "C" { void * aligned_alloc( size_t align, size_t size ); } // use default C routine for void *
    6460        T * aligned_alloc( size_t align ) {
    6561                //printf( "X5\n" );
    … …  
    7470
    7571        // Cforall dynamic allocation
     72        extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
    7673
    7774        T * alloc( void ) {
    … …  
    106103forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
    107104
    108 
    109 static inline forall( dtype T | sized(T) ) {
    110         T * align_alloc( size_t align ) {
    111                 //printf( "X13\n" );
    112                 return (T *)memalign( align, sizeof(T) );
    113         } // align_alloc
    114 
    115         T * align_alloc( size_t align, char fill ) {
    116                 //printf( "X14\n" );
    117                 T * ptr = (T *)memalign( align, sizeof(T) );
    118                 return (T *)memset( ptr, (int)fill, sizeof(T) );
    119         } // align_alloc
    120 
    121         T * align_alloc( size_t align, size_t dim ) {
    122                 //printf( "X15\n" );
    123                 return (T *)memalign( align, dim * sizeof(T) );
    124         } // align_alloc
    125 
    126         T * align_alloc( size_t align, size_t dim, char fill ) {
    127                 //printf( "X16\n" );
    128                 T * ptr = (T *)memalign( align, dim * sizeof(T) );
    129                 return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
    130         } // align_alloc
    131 } // distribution
    132 
    133 
    134 static inline forall( dtype T | sized(T) ) {
    135         // data, non-array types
    136 
    137         T * memset( T * dest, char c ) {
    138                 //printf( "X17\n" );
    139                 return (T *)memset( dest, c, sizeof(T) );
    140         } // memset
    141 
    142         extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
    143 
    144         T * memcpy( T * dest, const T * src ) {
    145                 //printf( "X18\n" );
    146                 return (T *)memcpy( dest, src, sizeof(T) );
    147         } // memcpy
    148 } // distribution
    149 
    150 static inline forall( dtype T | sized(T) ) {
    151         // data, array types
    152 
    153         T * memset( T dest[], size_t dim, char c ) {
    154                 //printf( "X19\n" );
    155                 return (T *)(void *)memset( dest, c, dim * sizeof(T) ); // C memset
    156         } // memset
    157 
    158         T * memcpy( T dest[], const T src[], size_t dim ) {
    159                 //printf( "X20\n" );
    160                 return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
    161         } // memcpy
    162 } // distribution
     105static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) {
     106        //printf( "X13\n" );
     107        return (T *)memalign( align, sizeof(T) );
     108} // align_alloc
     109static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) {
     110        //printf( "X14\n" );
     111    T * ptr = (T *)memalign( align, sizeof(T) );
     112    return (T *)memset( ptr, (int)fill, sizeof(T) );
     113} // align_alloc
     114
     115static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) {
     116        //printf( "X15\n" );
     117        return (T *)memalign( align, dim * sizeof(T) );
     118} // align_alloc
     119static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) {
     120        //printf( "X16\n" );
     121    T * ptr = (T *)memalign( align, dim * sizeof(T) );
     122    return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
     123} // align_alloc
     124
     125
     126// data, non-array types
     127static inline forall( dtype T | sized(T) ) T * memset( T * dest, char c ) {
     128        //printf( "X17\n" );
     129        return (T *)memset( dest, c, sizeof(T) );
     130} // memset
     131extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
     132static inline forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src ) {
     133        //printf( "X18\n" );
     134        return (T *)memcpy( dest, src, sizeof(T) );
     135} // memcpy
     136
     137// data, array types
     138static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
     139        //printf( "X19\n" );
     140        return (T *)(void *)memset( dest, c, dim * sizeof(T) ); // C memset
     141} // memset
     142static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {
     143        //printf( "X20\n" );
     144        return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
     145} // memcpy
    163146
    164147// allocation/deallocation and constructor/destructor, non-array types
    … …  
    206189//---------------------------------------
    207190
    208 forall( otype E | { int ?<?( E, E ); } ) {
    209         E * bsearch( E key, const E * vals, size_t dim );
    210         size_t bsearch( E key, const E * vals, size_t dim );
    211         E * bsearchl( E key, const E * vals, size_t dim );
    212         size_t bsearchl( E key, const E * vals, size_t dim );
    213         E * bsearchu( E key, const E * vals, size_t dim );
    214         size_t bsearchu( E key, const E * vals, size_t dim );
    215 
    216         void qsort( E * vals, size_t dim );
    217 } // distribution
    218 
    219 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) {
    220         E * bsearch( K key, const E * vals, size_t dim );
    221         size_t bsearch( K key, const E * vals, size_t dim );
    222         E * bsearchl( K key, const E * vals, size_t dim );
    223         size_t bsearchl( K key, const E * vals, size_t dim );
    224         E * bsearchu( K key, const E * vals, size_t dim );
    225         size_t bsearchu( K key, const E * vals, size_t dim );
    226 } // distribution
     191forall( otype E | { int ?<?( E, E ); } )
     192E * bsearch( E key, const E * vals, size_t dim );
     193
     194forall( otype E | { int ?<?( E, E ); } )
     195size_t bsearch( E key, const E * vals, size_t dim );
     196
     197forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     198E * bsearch( K key, const E * vals, size_t dim );
     199
     200forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     201size_t bsearch( K key, const E * vals, size_t dim );
     202
     203
     204forall( otype E | { int ?<?( E, E ); } )
     205E * bsearchl( E key, const E * vals, size_t dim );
     206
     207forall( otype E | { int ?<?( E, E ); } )
     208size_t bsearchl( E key, const E * vals, size_t dim );
     209
     210forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     211E * bsearchl( K key, const E * vals, size_t dim );
     212
     213forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     214size_t bsearchl( K key, const E * vals, size_t dim );
     215
     216
     217forall( otype E | { int ?<?( E, E ); } )
     218E * bsearchu( E key, const E * vals, size_t dim );
     219
     220forall( otype E | { int ?<?( E, E ); } )
     221size_t bsearchu( E key, const E * vals, size_t dim );
     222
     223forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     224E * bsearchu( K key, const E * vals, size_t dim );
     225
     226forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     227size_t bsearchu( K key, const E * vals, size_t dim );
     228
     229
     230forall( otype E | { int ?<?( E, E ); } )
     231void qsort( E * vals, size_t dim );
    227232
    228233//---------------------------------------

  • src/libcfa/stdlib.c

    r249d6e6 r863c413  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  2 06:15:05 2018
    13 // Update Count     : 448
     12// Last Modified On : Wed Jan  3 08:29:29 2018
     13// Update Count     : 444
    1414//
    1515
    … …  
    130130//---------------------------------------
    131131
    132 forall( otype E | { int ?<?( E, E ); } ) {
    133         E * bsearch( E key, const E * vals, size_t dim ) {
    134                 int cmp( const void * t1, const void * t2 ) {
    135                         return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
    136                 } // cmp
    137                 return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
    138         } // bsearch
    139 
    140         size_t bsearch( E key, const E * vals, size_t dim ) {
    141                 E * result = bsearch( key, vals, dim );
    142                 return result ? result - vals : dim;                    // pointer subtraction includes sizeof(E)
    143         } // bsearch
    144 
    145         size_t bsearchl( E key, const E * vals, size_t dim ) {
    146                 size_t l = 0, m, h = dim;
    147                 while ( l < h ) {
    148                         m = (l + h) / 2;
    149                         if ( (E &)(vals[m]) < key ) {                           // cast away const
    150                                 l = m + 1;
    151                         } else {
    152                                 h = m;
    153                         } // if
    154                 } // while
    155                 return l;
    156         } // bsearchl
    157 
    158         E * bsearchl( E key, const E * vals, size_t dim ) {
    159                 size_t posn = bsearchl( key, vals, dim );
    160                 return (E *)(&vals[posn]);                                              // cast away const
    161         } // bsearchl
    162 
    163         size_t bsearchu( E key, const E * vals, size_t dim ) {
    164                 size_t l = 0, m, h = dim;
    165                 while ( l < h ) {
    166                         m = (l + h) / 2;
    167                         if ( ! ( key < (E &)(vals[m]) ) ) {                     // cast away const
    168                                 l = m + 1;
    169                         } else {
    170                                 h = m;
    171                         } // if
    172                 } // while
    173                 return l;
    174         } // bsearchu
    175 
    176         E * bsearchu( E key, const E * vals, size_t dim ) {
    177                 size_t posn = bsearchu( key, vals, dim );
    178                 return (E *)(&vals[posn]);
    179         } // bsearchu
    180 
    181 
    182         void qsort( E * vals, size_t dim ) {
    183                 int cmp( const void * t1, const void * t2 ) {
    184                         return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
    185                 } // cmp
    186                 qsort( vals, dim, sizeof(E), cmp );
    187         } // qsort
    188 } // distribution
    189 
    190 
    191 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) {
    192         E * bsearch( K key, const E * vals, size_t dim ) {
    193                 int cmp( const void * t1, const void * t2 ) {
    194                         return *(K *)t1 < getKey( *(E *)t2 ) ? -1 : getKey( *(E *)t2 ) < *(K *)t1 ? 1 : 0;
    195                 } // cmp
    196                 return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
    197         } // bsearch
    198 
    199         size_t bsearch( K key, const E * vals, size_t dim ) {
    200                 E * result = bsearch( key, vals, dim );
    201                 return result ? result - vals : dim;                    // pointer subtraction includes sizeof(E)
    202         } // bsearch
    203 
    204         size_t bsearchl( K key, const E * vals, size_t dim ) {
    205                 size_t l = 0, m, h = dim;
    206                 while ( l < h ) {
    207                         m = (l + h) / 2;
    208                         if ( getKey( vals[m] ) < key ) {
    209                                 l = m + 1;
    210                         } else {
    211                                 h = m;
    212                         } // if
    213                 } // while
    214                 return l;
    215         } // bsearchl
    216 
    217         E * bsearchl( K key, const E * vals, size_t dim ) {
    218                 size_t posn = bsearchl( key, vals, dim );
    219                 return (E *)(&vals[posn]);                                              // cast away const
    220         } // bsearchl
    221 
    222         size_t bsearchu( K key, const E * vals, size_t dim ) {
    223                 size_t l = 0, m, h = dim;
    224                 while ( l < h ) {
    225                         m = (l + h) / 2;
    226                         if ( ! ( key < getKey( vals[m] ) ) ) {
    227                                 l = m + 1;
    228                         } else {
    229                                 h = m;
    230                         } // if
    231                 } // while
    232                 return l;
    233         } // bsearchu
    234 
    235         E * bsearchu( K key, const E * vals, size_t dim ) {
    236                 size_t posn = bsearchu( key, vals, dim );
    237                 return (E *)(&vals[posn]);
    238         } // bsearchu
    239 } // distribution
     132forall( otype E | { int ?<?( E, E ); } )
     133E * bsearch( E key, const E * vals, size_t dim ) {
     134        int cmp( const void * t1, const void * t2 ) {
     135                return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
     136        } // cmp
     137        return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
     138} // bsearch
     139
     140forall( otype E | { int ?<?( E, E ); } )
     141size_t bsearch( E key, const E * vals, size_t dim ) {
     142        E * result = bsearch( key, vals, dim );
     143        return result ? result - vals : dim;                            // pointer subtraction includes sizeof(E)
     144} // bsearch
     145
     146forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     147E * bsearch( K key, const E * vals, size_t dim ) {
     148        int cmp( const void * t1, const void * t2 ) {
     149                return *(K *)t1 < getKey( *(E *)t2 ) ? -1 : getKey( *(E *)t2 ) < *(K *)t1 ? 1 : 0;
     150        } // cmp
     151        return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
     152} // bsearch
     153
     154forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     155size_t bsearch( K key, const E * vals, size_t dim ) {
     156        E * result = bsearch( key, vals, dim );
     157        return result ? result - vals : dim;                            // pointer subtraction includes sizeof(E)
     158} // bsearch
     159
     160
     161forall( otype E | { int ?<?( E, E ); } )
     162size_t bsearchl( E key, const E * vals, size_t dim ) {
     163        size_t l = 0, m, h = dim;
     164        while ( l < h ) {
     165                m = (l + h) / 2;
     166                if ( (E &)(vals[m]) < key ) {                                   // cast away const
     167                        l = m + 1;
     168                } else {
     169                        h = m;
     170                } // if
     171        } // while
     172        return l;
     173} // bsearchl
     174
     175forall( otype E | { int ?<?( E, E ); } )
     176E * bsearchl( E key, const E * vals, size_t dim ) {
     177        size_t posn = bsearchl( key, vals, dim );
     178        return (E *)(&vals[posn]);                                                      // cast away const
     179} // bsearchl
     180
     181forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     182size_t bsearchl( K key, const E * vals, size_t dim ) {
     183        size_t l = 0, m, h = dim;
     184        while ( l < h ) {
     185                m = (l + h) / 2;
     186                if ( getKey( vals[m] ) < key ) {
     187                        l = m + 1;
     188                } else {
     189                        h = m;
     190                } // if
     191        } // while
     192        return l;
     193} // bsearchl
     194
     195forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     196E * bsearchl( K key, const E * vals, size_t dim ) {
     197        size_t posn = bsearchl( key, vals, dim );
     198        return (E *)(&vals[posn]);                                                      // cast away const
     199} // bsearchl
     200
     201
     202forall( otype E | { int ?<?( E, E ); } )
     203size_t bsearchu( E key, const E * vals, size_t dim ) {
     204        size_t l = 0, m, h = dim;
     205        while ( l < h ) {
     206                m = (l + h) / 2;
     207                if ( ! ( key < (E &)(vals[m]) ) ) {                             // cast away const
     208                        l = m + 1;
     209                } else {
     210                        h = m;
     211                } // if
     212        } // while
     213        return l;
     214} // bsearchu
     215
     216forall( otype E | { int ?<?( E, E ); } )
     217E * bsearchu( E key, const E * vals, size_t dim ) {
     218        size_t posn = bsearchu( key, vals, dim );
     219        return (E *)(&vals[posn]);
     220} // bsearchu
     221
     222forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     223size_t bsearchu( K key, const E * vals, size_t dim ) {
     224        size_t l = 0, m, h = dim;
     225        while ( l < h ) {
     226                m = (l + h) / 2;
     227                if ( ! ( key < getKey( vals[m] ) ) ) {
     228                        l = m + 1;
     229                } else {
     230                        h = m;
     231                } // if
     232        } // while
     233        return l;
     234} // bsearchu
     235
     236forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     237E * bsearchu( K key, const E * vals, size_t dim ) {
     238        size_t posn = bsearchu( key, vals, dim );
     239        return (E *)(&vals[posn]);
     240} // bsearchu
     241
     242
     243forall( otype E | { int ?<?( E, E ); } )
     244void qsort( E * vals, size_t dim ) {
     245        int cmp( const void * t1, const void * t2 ) {
     246                return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
     247        } // cmp
     248        qsort( vals, dim, sizeof(E), cmp );
     249} // qsort
    240250
    241251//---------------------------------------

  • src/tests/.expect/ifcond.txt

    r249d6e6 r863c413  
    22x != 0 && y != 0 correct
    33x == y correct
    4 s.i < 4 correct

  • src/tests/.expect/literals.x64.txt

    r249d6e6 r863c413  
    2121void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object586), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object587), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object588, _Bool __anonymous_object589), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object590), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object591, const char *__anonymous_object592), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object593), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object594, _Bool __anonymous_object595), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object596), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object597), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object598), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object599), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object600), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object601, const char *__anonymous_object602), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object603), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object604, const char *__anonymous_object605), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object606), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object607), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object608, const char *__anonymous_object609, unsigned long int __anonymous_object610), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object611, const char *__fmt__PCc_1, ...), void *__anonymous_object612, const char *__anonymous_object613);
    2222void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object614), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object615), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object616, _Bool __anonymous_object617), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object618), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object619, const char *__anonymous_object620), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object621), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object622, _Bool __anonymous_object623), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object624), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object625), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object626), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object627), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object628), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object629, const char *__anonymous_object630), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object631), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object632, const char *__anonymous_object633), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object634), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object635), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object636, const char *__anonymous_object637, unsigned long int __anonymous_object638), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object639, const char *__fmt__PCc_1, ...), void *__anonymous_object640, const void *__anonymous_object641);
    23 void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object642), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object643), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object644, _Bool __anonymous_object645), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object646), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object647, const char *__anonymous_object648), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object649), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object650, _Bool __anonymous_object651), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object652), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object653), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object654), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object655), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object657, const char *__anonymous_object658), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object659), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object660, const char *__anonymous_object661), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object663), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object664, const char *__anonymous_object665, unsigned long int __anonymous_object666), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object667, const char *__fmt__PCc_1, ...), void *__anonymous_object668, void *(*__anonymous_object669)(void *__anonymous_object670));
    24 void *__endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object671), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object672), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object673, _Bool __anonymous_object674), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object675), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object676, const char *__anonymous_object677), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object678), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object679, _Bool __anonymous_object680), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object681), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object684), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object685), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object686, const char *__anonymous_object687), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object688), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object689, const char *__anonymous_object690), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object691), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object692), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object693, const char *__anonymous_object694, unsigned long int __anonymous_object695), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object696, const char *__fmt__PCc_1, ...), void *__anonymous_object697);
    25 void *__sep__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object698), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object699), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object700, _Bool __anonymous_object701), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object702), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object703, const char *__anonymous_object704), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object705), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object706, _Bool __anonymous_object707), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object708), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object709), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object710), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object711), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object712), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object713, const char *__anonymous_object714), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object715), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object716, const char *__anonymous_object717), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object718), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object720, const char *__anonymous_object721, unsigned long int __anonymous_object722), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object723, const char *__fmt__PCc_1, ...), void *__anonymous_object724);
    26 void *__sepTuple__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object725), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object726), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object727, _Bool __anonymous_object728), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object730, const char *__anonymous_object731), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object733, _Bool __anonymous_object734), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object735), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object736), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object737), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object738), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object740, const char *__anonymous_object741), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object742), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object743, const char *__anonymous_object744), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object745), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object747, const char *__anonymous_object748, unsigned long int __anonymous_object749), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object750, const char *__fmt__PCc_1, ...), void *__anonymous_object751);
    27 void *__sepOn__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object752), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object757, const char *__anonymous_object758), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object760, _Bool __anonymous_object761), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object762), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object764), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object765), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object767, const char *__anonymous_object768), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object769), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object770, const char *__anonymous_object771), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object772), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object773), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object774, const char *__anonymous_object775, unsigned long int __anonymous_object776), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object777, const char *__fmt__PCc_1, ...), void *__anonymous_object778);
    28 void *__sepOff__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object779), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object780), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object781, _Bool __anonymous_object782), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object783), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object784, const char *__anonymous_object785), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object787, _Bool __anonymous_object788), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object789), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object790), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object791), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object792), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object793), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object794, const char *__anonymous_object795), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object796), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object797, const char *__anonymous_object798), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object799), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object800), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object801, const char *__anonymous_object802, unsigned long int __anonymous_object803), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object804, const char *__fmt__PCc_1, ...), void *__anonymous_object805);
    29 void *__sepDisable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object806), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object807), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object808, _Bool __anonymous_object809), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object810), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object811, const char *__anonymous_object812), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object814, _Bool __anonymous_object815), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object816), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object817), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object818), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object819), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object820), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object821, const char *__anonymous_object822), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object823), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object824, const char *__anonymous_object825), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object826), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object827), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object828, const char *__anonymous_object829, unsigned long int __anonymous_object830), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object831, const char *__fmt__PCc_1, ...), void *__anonymous_object832);
    30 void *__sepEnable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object833), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object834), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object835, _Bool __anonymous_object836), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object837), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object838, const char *__anonymous_object839), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object841, _Bool __anonymous_object842), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object843), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object844), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object845), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object846), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object847), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object848, const char *__anonymous_object849), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object850), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object851, const char *__anonymous_object852), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object853), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object854), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object855, const char *__anonymous_object856, unsigned long int __anonymous_object857), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object858, const char *__fmt__PCc_1, ...), void *__anonymous_object859);
    31 void *___operator_bitor__A0_2_0_1____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_bitor__Fd0_d0tVARGS2__Fd0_d0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object860)(), void *__anonymous_object861, void *__anonymous_object862), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object863)(), void *__anonymous_object864, void *__anonymous_object865), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object866)(), void *__anonymous_object867, void *__anonymous_object868), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object869)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object870, void *__anonymous_object871), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__F2tT_2tT2tT__1)(void *__anonymous_object872, void *__anonymous_object873), __attribute__ ((unused)) void (*___constructor__F_2tT__1)(void *__anonymous_object874), __attribute__ ((unused)) void (*___constructor__F_2tT2tT__1)(void *__anonymous_object875, void *__anonymous_object876), __attribute__ ((unused)) void (*___destructor__F_2tT__1)(void *__anonymous_object877), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype2tT__1)(void *__anonymous_object878, void *__anonymous_object879), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object880), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object881), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object882, _Bool __anonymous_object883), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object884), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object885, const char *__anonymous_object886), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object887), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object888, _Bool __anonymous_object889), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object890), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object891), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object892), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object893), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object895, const char *__anonymous_object896), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object897), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object898, const char *__anonymous_object899), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object900), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object901), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object902, const char *__anonymous_object903, unsigned long int __anonymous_object904), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object905, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype7tParams__1)(void *__anonymous_object906, void *__anonymous_object907), void *__os__7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
     23void *___operator_bitor__A0_2_0_1____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_bitor__Fd0_d0tVARGS2__Fd0_d0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object642)(), void *__anonymous_object643, void *__anonymous_object644), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object645)(), void *__anonymous_object646, void *__anonymous_object647), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object648)(), void *__anonymous_object649, void *__anonymous_object650), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object651)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object652, void *__anonymous_object653), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__F2tT_2tT2tT__1)(void *__anonymous_object654, void *__anonymous_object655), __attribute__ ((unused)) void (*___constructor__F_2tT__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*___constructor__F_2tT2tT__1)(void *__anonymous_object657, void *__anonymous_object658), __attribute__ ((unused)) void (*___destructor__F_2tT__1)(void *__anonymous_object659), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype2tT__1)(void *__anonymous_object660, void *__anonymous_object661), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object663), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object664, _Bool __anonymous_object665), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object666), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object667, const char *__anonymous_object668), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object669), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object670, _Bool __anonymous_object671), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object672), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object673), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object675), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object676), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object677, const char *__anonymous_object678), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object679), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object680, const char *__anonymous_object681), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object684, const char *__anonymous_object685, unsigned long int __anonymous_object686), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object687, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype7tParams__1)(void *__anonymous_object688, void *__anonymous_object689), void *__os__7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
     24void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object691), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object692, _Bool __anonymous_object693), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object694), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object695, const char *__anonymous_object696), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object697), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object698, _Bool __anonymous_object699), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object700), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object701), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object702), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object703), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object704), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object705, const char *__anonymous_object706), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object707), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object708, const char *__anonymous_object709), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object710), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object711), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object712, const char *__anonymous_object713, unsigned long int __anonymous_object714), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object715, const char *__fmt__PCc_1, ...), void *__anonymous_object716, void *(*__anonymous_object717)(void *__anonymous_object718));
     25void *__endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object720), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object721, _Bool __anonymous_object722), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object723), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object724, const char *__anonymous_object725), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object726), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object727, _Bool __anonymous_object728), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object733), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object734, const char *__anonymous_object735), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object736), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object737, const char *__anonymous_object738), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object740), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object741, const char *__anonymous_object742, unsigned long int __anonymous_object743), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object744, const char *__fmt__PCc_1, ...), void *__anonymous_object745);
     26void *__sep__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object767), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), void *__anonymous_object772);
     27void *__sepTuple__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object773), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object774), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object775, _Bool __anonymous_object776), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object777), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object778, const char *__anonymous_object779), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object780), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object781, _Bool __anonymous_object782), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object783), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object784), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object788, const char *__anonymous_object789), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object790), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object791, const char *__anonymous_object792), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object793), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object794), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object795, const char *__anonymous_object796, unsigned long int __anonymous_object797), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object798, const char *__fmt__PCc_1, ...), void *__anonymous_object799);
     28void *__sepOn__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object800), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object801), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object802, _Bool __anonymous_object803), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object804), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object805, const char *__anonymous_object806), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object807), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object808, _Bool __anonymous_object809), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object810), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object811), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object812), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object814), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object815, const char *__anonymous_object816), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object817), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object818, const char *__anonymous_object819), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object820), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object821), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object822, const char *__anonymous_object823, unsigned long int __anonymous_object824), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object825, const char *__fmt__PCc_1, ...), void *__anonymous_object826);
     29void *__sepOff__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object827), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object828), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object829, _Bool __anonymous_object830), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object831), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object832, const char *__anonymous_object833), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object834), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object835, _Bool __anonymous_object836), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object837), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object838), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object839), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object841), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object842, const char *__anonymous_object843), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object844), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object845, const char *__anonymous_object846), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object847), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object848), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object849, const char *__anonymous_object850, unsigned long int __anonymous_object851), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object852, const char *__fmt__PCc_1, ...), void *__anonymous_object853);
     30void *__sepDisable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object854), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object855), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object856, _Bool __anonymous_object857), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object858), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object859, const char *__anonymous_object860), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object861), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object862, _Bool __anonymous_object863), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object864), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object865), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object866), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object867), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object868), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object869, const char *__anonymous_object870), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object871), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object872, const char *__anonymous_object873), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object874), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object875), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object876, const char *__anonymous_object877, unsigned long int __anonymous_object878), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object879, const char *__fmt__PCc_1, ...), void *__anonymous_object880);
     31void *__sepEnable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object881), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object882), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object883, _Bool __anonymous_object884), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object885), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object886, const char *__anonymous_object887), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object888), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object889, _Bool __anonymous_object890), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object891), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object892), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object893), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object895), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object896, const char *__anonymous_object897), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object898), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object899, const char *__anonymous_object900), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object901), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object902), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object903, const char *__anonymous_object904, unsigned long int __anonymous_object905), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object906, const char *__fmt__PCc_1, ...), void *__anonymous_object907);
    3232void __write__A0_3_0_0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_assign__Fd2_d2d2____constructor__F_d2____constructor__F_d2d2____destructor__F_d2____operator_preincr__Fd2_d2____operator_predecr__Fd2_d2____operator_equal__Fi_d2d2____operator_notequal__Fi_d2d2____operator_deref__Fd1_d2__F_d2d2d0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object908)(), void *__anonymous_object909), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object910)(), void *__anonymous_object911, void *__anonymous_object912), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object913)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object914), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object915)(), void *__anonymous_object916, void *__anonymous_object917), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object918)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object919, void *__anonymous_object920), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object921)(), void *__anonymous_object922, void *__anonymous_object923), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object924)(), void *__anonymous_object925, void *__anonymous_object926), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object927)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object928, void *__anonymous_object929), __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__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object930, void *__anonymous_object931), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object932), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object933, void *__anonymous_object934), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object935), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype9telt_type__1)(void *__anonymous_object936, void *__anonymous_object937), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object939), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object940, _Bool __anonymous_object941), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object942), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object943, const char *__anonymous_object944), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object945), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object946, _Bool __anonymous_object947), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object952), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object953, const char *__anonymous_object954), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object955), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object956, const char *__anonymous_object957), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object958), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object959), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object960, const char *__anonymous_object961, unsigned long int __anonymous_object962), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object963, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object964, void *__anonymous_object965), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object966), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object969), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object970), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object971), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object974, void *__anonymous_object975), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object976), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__7tostype_1);
    3333void __write_reverse__A0_3_0_0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_assign__Fd2_d2d2____constructor__F_d2____constructor__F_d2d2____destructor__F_d2____operator_preincr__Fd2_d2____operator_predecr__Fd2_d2____operator_equal__Fi_d2d2____operator_notequal__Fi_d2d2____operator_deref__Fd1_d2__F_d2d2d0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object977)(), void *__anonymous_object978), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object979)(), void *__anonymous_object980, void *__anonymous_object981), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object982)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object983), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object984)(), void *__anonymous_object985, void *__anonymous_object986), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object987)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object988, void *__anonymous_object989), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object990)(), void *__anonymous_object991, void *__anonymous_object992), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object993)(), void *__anonymous_object994, void *__anonymous_object995), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object996)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object997, void *__anonymous_object998), __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__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object999, void *__anonymous_object1000), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object1002, void *__anonymous_object1003), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object1004), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype9telt_type__1)(void *__anonymous_object1005, void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object1009, _Bool __anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object1015, _Bool __anonymous_object1016), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object1017), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object1018), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object1019), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object1020), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object1021), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object1022, const char *__anonymous_object1023), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object1024), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object1025, const char *__anonymous_object1026), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object1028), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object1029, const char *__anonymous_object1030, unsigned long int __anonymous_object1031), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object1032, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object1033, void *__anonymous_object1034), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object1035), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object1038), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object1039), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object1040), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object1043, void *__anonymous_object1044), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object1045), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__7tostype_1);

  • src/tests/.expect/literals.x86.txt

    r249d6e6 r863c413  
    2121void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object586), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object587), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object588, _Bool __anonymous_object589), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object590), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object591, const char *__anonymous_object592), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object593), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object594, _Bool __anonymous_object595), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object596), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object597), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object598), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object599), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object600), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object601, const char *__anonymous_object602), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object603), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object604, const char *__anonymous_object605), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object606), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object607), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object608, const char *__anonymous_object609, unsigned long int __anonymous_object610), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object611, const char *__fmt__PCc_1, ...), void *__anonymous_object612, const char *__anonymous_object613);
    2222void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object614), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object615), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object616, _Bool __anonymous_object617), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object618), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object619, const char *__anonymous_object620), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object621), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object622, _Bool __anonymous_object623), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object624), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object625), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object626), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object627), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object628), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object629, const char *__anonymous_object630), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object631), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object632, const char *__anonymous_object633), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object634), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object635), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object636, const char *__anonymous_object637, unsigned long int __anonymous_object638), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object639, const char *__fmt__PCc_1, ...), void *__anonymous_object640, const void *__anonymous_object641);
    23 void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object642), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object643), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object644, _Bool __anonymous_object645), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object646), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object647, const char *__anonymous_object648), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object649), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object650, _Bool __anonymous_object651), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object652), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object653), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object654), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object655), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object657, const char *__anonymous_object658), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object659), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object660, const char *__anonymous_object661), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object663), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object664, const char *__anonymous_object665, unsigned long int __anonymous_object666), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object667, const char *__fmt__PCc_1, ...), void *__anonymous_object668, void *(*__anonymous_object669)(void *__anonymous_object670));
    24 void *__endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object671), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object672), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object673, _Bool __anonymous_object674), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object675), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object676, const char *__anonymous_object677), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object678), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object679, _Bool __anonymous_object680), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object681), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object684), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object685), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object686, const char *__anonymous_object687), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object688), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object689, const char *__anonymous_object690), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object691), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object692), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object693, const char *__anonymous_object694, unsigned long int __anonymous_object695), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object696, const char *__fmt__PCc_1, ...), void *__anonymous_object697);
    25 void *__sep__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object698), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object699), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object700, _Bool __anonymous_object701), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object702), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object703, const char *__anonymous_object704), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object705), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object706, _Bool __anonymous_object707), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object708), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object709), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object710), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object711), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object712), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object713, const char *__anonymous_object714), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object715), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object716, const char *__anonymous_object717), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object718), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object720, const char *__anonymous_object721, unsigned long int __anonymous_object722), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object723, const char *__fmt__PCc_1, ...), void *__anonymous_object724);
    26 void *__sepTuple__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object725), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object726), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object727, _Bool __anonymous_object728), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object730, const char *__anonymous_object731), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object733, _Bool __anonymous_object734), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object735), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object736), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object737), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object738), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object740, const char *__anonymous_object741), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object742), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object743, const char *__anonymous_object744), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object745), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object747, const char *__anonymous_object748, unsigned long int __anonymous_object749), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object750, const char *__fmt__PCc_1, ...), void *__anonymous_object751);
    27 void *__sepOn__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object752), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object757, const char *__anonymous_object758), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object760, _Bool __anonymous_object761), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object762), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object764), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object765), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object767, const char *__anonymous_object768), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object769), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object770, const char *__anonymous_object771), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object772), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object773), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object774, const char *__anonymous_object775, unsigned long int __anonymous_object776), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object777, const char *__fmt__PCc_1, ...), void *__anonymous_object778);
    28 void *__sepOff__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object779), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object780), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object781, _Bool __anonymous_object782), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object783), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object784, const char *__anonymous_object785), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object787, _Bool __anonymous_object788), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object789), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object790), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object791), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object792), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object793), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object794, const char *__anonymous_object795), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object796), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object797, const char *__anonymous_object798), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object799), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object800), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object801, const char *__anonymous_object802, unsigned long int __anonymous_object803), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object804, const char *__fmt__PCc_1, ...), void *__anonymous_object805);
    29 void *__sepDisable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object806), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object807), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object808, _Bool __anonymous_object809), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object810), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object811, const char *__anonymous_object812), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object814, _Bool __anonymous_object815), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object816), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object817), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object818), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object819), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object820), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object821, const char *__anonymous_object822), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object823), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object824, const char *__anonymous_object825), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object826), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object827), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object828, const char *__anonymous_object829, unsigned long int __anonymous_object830), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object831, const char *__fmt__PCc_1, ...), void *__anonymous_object832);
    30 void *__sepEnable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object833), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object834), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object835, _Bool __anonymous_object836), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object837), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object838, const char *__anonymous_object839), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object841, _Bool __anonymous_object842), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object843), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object844), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object845), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object846), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object847), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object848, const char *__anonymous_object849), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object850), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object851, const char *__anonymous_object852), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object853), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object854), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object855, const char *__anonymous_object856, unsigned long int __anonymous_object857), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object858, const char *__fmt__PCc_1, ...), void *__anonymous_object859);
    31 void *___operator_bitor__A0_2_0_1____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_bitor__Fd0_d0tVARGS2__Fd0_d0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object860)(), void *__anonymous_object861, void *__anonymous_object862), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object863)(), void *__anonymous_object864, void *__anonymous_object865), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object866)(), void *__anonymous_object867, void *__anonymous_object868), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object869)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object870, void *__anonymous_object871), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__F2tT_2tT2tT__1)(void *__anonymous_object872, void *__anonymous_object873), __attribute__ ((unused)) void (*___constructor__F_2tT__1)(void *__anonymous_object874), __attribute__ ((unused)) void (*___constructor__F_2tT2tT__1)(void *__anonymous_object875, void *__anonymous_object876), __attribute__ ((unused)) void (*___destructor__F_2tT__1)(void *__anonymous_object877), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype2tT__1)(void *__anonymous_object878, void *__anonymous_object879), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object880), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object881), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object882, _Bool __anonymous_object883), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object884), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object885, const char *__anonymous_object886), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object887), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object888, _Bool __anonymous_object889), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object890), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object891), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object892), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object893), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object895, const char *__anonymous_object896), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object897), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object898, const char *__anonymous_object899), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object900), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object901), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object902, const char *__anonymous_object903, unsigned long int __anonymous_object904), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object905, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype7tParams__1)(void *__anonymous_object906, void *__anonymous_object907), void *__os__7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
     23void *___operator_bitor__A0_2_0_1____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_bitor__Fd0_d0tVARGS2__Fd0_d0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object642)(), void *__anonymous_object643, void *__anonymous_object644), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object645)(), void *__anonymous_object646, void *__anonymous_object647), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object648)(), void *__anonymous_object649, void *__anonymous_object650), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object651)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object652, void *__anonymous_object653), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__F2tT_2tT2tT__1)(void *__anonymous_object654, void *__anonymous_object655), __attribute__ ((unused)) void (*___constructor__F_2tT__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*___constructor__F_2tT2tT__1)(void *__anonymous_object657, void *__anonymous_object658), __attribute__ ((unused)) void (*___destructor__F_2tT__1)(void *__anonymous_object659), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype2tT__1)(void *__anonymous_object660, void *__anonymous_object661), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object663), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object664, _Bool __anonymous_object665), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object666), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object667, const char *__anonymous_object668), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object669), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object670, _Bool __anonymous_object671), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object672), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object673), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object675), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object676), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object677, const char *__anonymous_object678), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object679), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object680, const char *__anonymous_object681), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object684, const char *__anonymous_object685, unsigned long int __anonymous_object686), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object687, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype7tParams__1)(void *__anonymous_object688, void *__anonymous_object689), void *__os__7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
     24void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object691), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object692, _Bool __anonymous_object693), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object694), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object695, const char *__anonymous_object696), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object697), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object698, _Bool __anonymous_object699), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object700), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object701), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object702), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object703), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object704), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object705, const char *__anonymous_object706), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object707), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object708, const char *__anonymous_object709), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object710), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object711), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object712, const char *__anonymous_object713, unsigned long int __anonymous_object714), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object715, const char *__fmt__PCc_1, ...), void *__anonymous_object716, void *(*__anonymous_object717)(void *__anonymous_object718));
     25void *__endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object720), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object721, _Bool __anonymous_object722), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object723), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object724, const char *__anonymous_object725), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object726), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object727, _Bool __anonymous_object728), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object733), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object734, const char *__anonymous_object735), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object736), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object737, const char *__anonymous_object738), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object740), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object741, const char *__anonymous_object742, unsigned long int __anonymous_object743), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object744, const char *__fmt__PCc_1, ...), void *__anonymous_object745);
     26void *__sep__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object767), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), void *__anonymous_object772);
     27void *__sepTuple__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object773), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object774), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object775, _Bool __anonymous_object776), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object777), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object778, const char *__anonymous_object779), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object780), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object781, _Bool __anonymous_object782), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object783), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object784), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object788, const char *__anonymous_object789), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object790), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object791, const char *__anonymous_object792), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object793), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object794), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object795, const char *__anonymous_object796, unsigned long int __anonymous_object797), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object798, const char *__fmt__PCc_1, ...), void *__anonymous_object799);
     28void *__sepOn__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object800), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object801), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object802, _Bool __anonymous_object803), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object804), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object805, const char *__anonymous_object806), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object807), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object808, _Bool __anonymous_object809), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object810), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object811), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object812), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object814), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object815, const char *__anonymous_object816), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object817), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object818, const char *__anonymous_object819), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object820), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object821), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object822, const char *__anonymous_object823, unsigned long int __anonymous_object824), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object825, const char *__fmt__PCc_1, ...), void *__anonymous_object826);
     29void *__sepOff__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object827), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object828), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object829, _Bool __anonymous_object830), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object831), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object832, const char *__anonymous_object833), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object834), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object835, _Bool __anonymous_object836), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object837), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object838), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object839), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object841), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object842, const char *__anonymous_object843), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object844), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object845, const char *__anonymous_object846), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object847), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object848), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object849, const char *__anonymous_object850, unsigned long int __anonymous_object851), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object852, const char *__fmt__PCc_1, ...), void *__anonymous_object853);
     30void *__sepDisable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object854), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object855), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object856, _Bool __anonymous_object857), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object858), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object859, const char *__anonymous_object860), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object861), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object862, _Bool __anonymous_object863), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object864), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object865), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object866), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object867), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object868), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object869, const char *__anonymous_object870), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object871), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object872, const char *__anonymous_object873), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object874), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object875), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object876, const char *__anonymous_object877, unsigned long int __anonymous_object878), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object879, const char *__fmt__PCc_1, ...), void *__anonymous_object880);
     31void *__sepEnable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object881), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object882), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object883, _Bool __anonymous_object884), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object885), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object886, const char *__anonymous_object887), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object888), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object889, _Bool __anonymous_object890), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object891), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object892), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object893), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object895), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object896, const char *__anonymous_object897), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object898), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object899, const char *__anonymous_object900), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object901), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object902), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object903, const char *__anonymous_object904, unsigned long int __anonymous_object905), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object906, const char *__fmt__PCc_1, ...), void *__anonymous_object907);
    3232void __write__A0_3_0_0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_assign__Fd2_d2d2____constructor__F_d2____constructor__F_d2d2____destructor__F_d2____operator_preincr__Fd2_d2____operator_predecr__Fd2_d2____operator_equal__Fi_d2d2____operator_notequal__Fi_d2d2____operator_deref__Fd1_d2__F_d2d2d0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object908)(), void *__anonymous_object909), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object910)(), void *__anonymous_object911, void *__anonymous_object912), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object913)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object914), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object915)(), void *__anonymous_object916, void *__anonymous_object917), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object918)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object919, void *__anonymous_object920), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object921)(), void *__anonymous_object922, void *__anonymous_object923), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object924)(), void *__anonymous_object925, void *__anonymous_object926), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object927)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object928, void *__anonymous_object929), __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__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object930, void *__anonymous_object931), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object932), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object933, void *__anonymous_object934), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object935), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype9telt_type__1)(void *__anonymous_object936, void *__anonymous_object937), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object939), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object940, _Bool __anonymous_object941), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object942), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object943, const char *__anonymous_object944), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object945), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object946, _Bool __anonymous_object947), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object952), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object953, const char *__anonymous_object954), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object955), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object956, const char *__anonymous_object957), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object958), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object959), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object960, const char *__anonymous_object961, unsigned long int __anonymous_object962), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object963, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object964, void *__anonymous_object965), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object966), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object969), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object970), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object971), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object974, void *__anonymous_object975), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object976), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__7tostype_1);
    3333void __write_reverse__A0_3_0_0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_assign__Fd2_d2d2____constructor__F_d2____constructor__F_d2d2____destructor__F_d2____operator_preincr__Fd2_d2____operator_predecr__Fd2_d2____operator_equal__Fi_d2d2____operator_notequal__Fi_d2d2____operator_deref__Fd1_d2__F_d2d2d0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object977)(), void *__anonymous_object978), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object979)(), void *__anonymous_object980, void *__anonymous_object981), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object982)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object983), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object984)(), void *__anonymous_object985, void *__anonymous_object986), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object987)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object988, void *__anonymous_object989), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object990)(), void *__anonymous_object991, void *__anonymous_object992), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object993)(), void *__anonymous_object994, void *__anonymous_object995), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object996)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object997, void *__anonymous_object998), __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__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object999, void *__anonymous_object1000), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object1002, void *__anonymous_object1003), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object1004), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype9telt_type__1)(void *__anonymous_object1005, void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object1009, _Bool __anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object1015, _Bool __anonymous_object1016), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object1017), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object1018), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object1019), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object1020), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object1021), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object1022, const char *__anonymous_object1023), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object1024), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object1025, const char *__anonymous_object1026), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object1028), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object1029, const char *__anonymous_object1030, unsigned long int __anonymous_object1031), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object1032, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object1033, void *__anonymous_object1034), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object1035), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object1038), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object1039), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object1040), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object1043, void *__anonymous_object1044), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object1045), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__7tostype_1);

  • src/tests/ifcond.c

    r249d6e6 r863c413  
    99// Author           : Peter A. Buhr
    1010// Created On       : Sat Aug 26 10:13:11 2017
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  2 09:55:02 2018
    13 // Update Count     : 15
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Fri Sep 01 15:22:19 2017
     13// Update Count     : 14
    1414//
    1515
    … …  
    4040                sout | "x != y incorrect" | endl;
    4141        } // if
    42 
    43         if ( struct S { int i; } s = { 3 }; s.i < 4 ) {
    44                 sout | "s.i < 4 correct" | endl;
    45         } else {
    46                 sout | "s.i >= 4 incorrect" | endl;
    47         } // if
    4842} // main
    4943
Note: See TracChangeset for help on using the changeset viewer.