Changeset b429026


Ignore:
Timestamp:
Jun 4, 2018, 11:55:02 AM (3 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, with_gc
Children:
ee3c93d
Parents:
0a75b77 (diff), 249d6e6 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Files:
3 added
29 edited

Legend:

Unmodified
Added
Removed
  • doc/theses/thierry_delisle/.gitignore

    r0a75b77 rb429026  
    2525*.pdf
    2626*.png
     27*.ps
    2728figures/*.tex
    2829
  • doc/theses/thierry_delisle/Makefile

    r0a75b77 rb429026  
    8888        mkdir -p ${Build}
    8989
    90 %.tex : %.fig
     90%.tex : %.fig ${Build}
    9191        fig2dev -L eepic $< > ${Build}/$@
    9292
    93 %.ps : %.fig
     93%.ps : %.fig ${Build}
    9494        fig2dev -L ps $< > ${Build}/$@
    9595
    96 %.pstex : %.fig
     96%.pstex : %.fig ${Build}
    9797        fig2dev -L pstex $< > ${Build}/$@
    9898        fig2dev -L pstex_t -p ${Build}/$@ $< > ${Build}/$@_t
     
    101101# Tools to generate png files
    102102# to create a png we create a pdf and convert it to png
    103 %.png : build/%.pstex figures/%.tex
     103%.png : build/%.pstex figures/%.tex ${Build}
    104104        echo ${basename $@}
    105105        ${LaTeX} figures/${basename $@}.tex
     
    109109
    110110# creating a pdf of a figure requires generating some latex that just includes the figure
    111 figures/%.tex: build/%.pstex
     111figures/%.tex: build/%.pstex ${Build}
    112112        echo -n         "\documentclass[preview]{standalone}\n"         \
    113113                        "\usepackage[T1]{fontenc}\n"                    \
  • src/Parser/TypedefTable.cc

    r0a75b77 rb429026  
    1010// Created On       : Sat May 16 15:20:13 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed May 30 18:04:38 2018
    13 // Update Count     : 148
     12// Last Modified On : Fri Jun  1 16:54:18 2018
     13// Update Count     : 155
    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*/ ) {
     60void TypedefTable::addToScope( const std::string & identifier, int kind, const char * locn __attribute__((unused)) ) {
    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*/ ) {
     67void TypedefTable::addToEnclosingScope( const std::string & identifier, int kind, const char * locn __attribute__((unused)) ) {
    6868        assert( kindTable.currentScope() >= 1 );
    6969        auto scope = kindTable.currentScope() - 1;
    70         debugPrint( cerr << "Adding2 at " /* << locn */ << " " << identifier << " as kind " << kind << " scope " << scope << endl );
     70        debugPrint( cerr << "Adding+1 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

    r0a75b77 rb429026  
    1010// Created On       : Sat May 16 15:24:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed May 30 17:02:49 2018
    13 // Update Count     : 82
     12// Last Modified On : Thu May 31 23:23:47 2018
     13// Update Count     : 83
    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

    r0a75b77 rb429026  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May 31 15:11:40 2018
    13 // Update Count     : 3444
     12// Last Modified On : Fri Jun  1 17:59:57 2018
     13// Update Count     : 3476
    1414//
    1515
     
    304304%type<en> enumerator_value_opt
    305305
    306 %type<decl> exception_declaration external_definition external_definition_list external_definition_list_opt
     306%type<decl> exception_declaration external_definition external_definition_list external_definition_list_no_pop_push 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; }
    647646        | string_literal
    648647                { $$ = new ExpressionNode( $1 ); }
     
    988987                { $$ = new StatementNode( build_if( $3, $5, $7 ) ); }
    989988        ;
    990 
    991989
    992990if_control_expression:
     
    13831381cfa_function_declaration:                                                               // CFA
    13841382        cfa_function_specifier
    1385                 { $$ = $1; }
    13861383        | type_qualifier_list cfa_function_specifier
    13871384                { $$ = $2->addQualifiers( $1 ); }
     
    14401437        TYPEDEF cfa_variable_specifier
    14411438                {
    1442                         typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname /*, "1"*/ );
     1439                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "1" );
    14431440                        $$ = $2->addTypedef();
    14441441                }
    14451442        | TYPEDEF cfa_function_specifier
    14461443                {
    1447                         typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname /*, "2"*/ );
     1444                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "2" );
    14481445                        $$ = $2->addTypedef();
    14491446                }
    14501447        | cfa_typedef_declaration pop ',' push no_attr_identifier
    14511448                {
    1452                         typedefTable.addToEnclosingScope( *$5, TYPEDEFname /*, "3"*/ );
     1449                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname, "3" );
    14531450                        $$ = $1->appendList( $1->cloneType( $5 ) );
    14541451                }
     
    14611458        TYPEDEF type_specifier declarator
    14621459                {
    1463                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname /*, "4"*/ );
     1460                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
    14641461                        $$ = $3->addType( $2 )->addTypedef();
    14651462                }
    14661463        | typedef_declaration pop ',' push declarator
    14671464                {
    1468                         typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname /*, "5"*/ );
     1465                        typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname, "5" );
    14691466                        $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
    14701467                }
    14711468        | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
    14721469                {
    1473                         typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname /*, "6"*/ );
     1470                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" );
    14741471                        $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
    14751472                }
    14761473        | type_specifier TYPEDEF declarator
    14771474                {
    1478                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname /*, "7"*/ );
     1475                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "7" );
    14791476                        $$ = $3->addType( $1 )->addTypedef();
    14801477                }
    14811478        | type_specifier TYPEDEF type_qualifier_list declarator
    14821479                {
    1483                         typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname /*, "8"*/ );
     1480                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" );
    14841481                        $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
    14851482                }
     
    19371934                { $$ = nullptr; }
    19381935        | bit_subrange_size
    1939                 { $$ = $1; }
    19401936        ;
    19411937
     
    21872183type_parameter_list:                                                                    // CFA
    21882184        type_parameter
    2189                 { $$ = $1; }
    21902185        | type_parameter_list ',' type_parameter
    21912186                { $$ = $1->appendList( $3 ); }
     
    22012196type_parameter:                                                                                 // CFA
    22022197        type_class no_attr_identifier_or_type_name
    2203                 { typedefTable.addToScope( *$2, TYPEDEFname /*, "9"*/ ); }
     2198                { typedefTable.addToScope( *$2, TYPEDEFname, "9" ); }
    22042199          type_initializer_opt assertion_list_opt
    22052200                { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
     
    22702265        no_attr_identifier_or_type_name
    22712266                {
    2272                         typedefTable.addToEnclosingScope( *$1, TYPEDEFname /*, "10"*/ );
     2267                        typedefTable.addToEnclosingScope( *$1, TYPEDEFname, "10" );
    22732268                        $$ = DeclarationNode::newTypeDecl( $1, 0 );
    22742269                }
    22752270        | no_attr_identifier_or_type_name '(' type_parameter_list ')'
    22762271                {
    2277                         typedefTable.addToEnclosingScope( *$1, TYPEGENname /*, "11"*/ );
     2272                        typedefTable.addToEnclosingScope( *$1, TYPEGENname, "11" );
    22782273                        $$ = DeclarationNode::newTypeDecl( $1, $3 );
    22792274                }
     
    23302325        ;
    23312326
     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.
     2333external_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
    23322341external_definition_list_opt:
    23332342        // empty
    23342343                { $$ = nullptr; }
    2335         | external_definition_list
     2344        | external_definition_list_no_pop_push
    23362345        ;
    23372346
     
    23392348        declaration
    23402349        | external_function_definition
     2350        | EXTENSION external_definition                                         // GCC, multiple __extension__ allowed, meaning unknown
     2351                {
     2352                        distExt( $2 );                                                          // mark all fields in list
     2353                        $$ = $2;
     2354                }
    23412355        | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
    23422356                {
     
    23482362                        linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
    23492363                }
    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 '}'
     2364          '{' external_definition_list_opt '}'
    23552365                {
    23562366                        linkage = linkageStack.top();
    23572367                        linkageStack.pop();
    2358                         $$ = $6;
    2359                 }
    2360         | EXTENSION external_definition                                         // GCC, multiple __extension__ allowed, meaning unknown
    2361                 {
    2362                         distExt( $2 );                                                          // mark all fields in list
    2363                         $$ = $2;
     2368                        $$ = $5;
    23642369                }
    23652370        | type_qualifier_list
    23662371                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
    2367           '{' external_definition_list push '}'                  // CFA, namespace
     2372          '{' external_definition_list_opt '}'                          // CFA, namespace
    23682373                {
    23692374                        for ( DeclarationNode * iter = $4; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
     
    23782383        | declaration_qualifier_list
    23792384                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
    2380           '{' external_definition_list '}'                                       // CFA, namespace
     2385          '{' external_definition_list_opt '}'                          // CFA, namespace
    23812386                {
    23822387                        for ( DeclarationNode * iter = $4; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
     
    23942399                        if ( $2->type->forall ) xxx = forall = true; // remember generic type
    23952400                }
    2396           '{' external_definition_list '}'                                      // CFA, namespace
     2401          '{' external_definition_list_opt '}'                          // CFA, namespace
    23972402                {
    23982403                        for ( DeclarationNode * iter = $5; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
     
    27152720        typedef
    27162721                // hide type name in enclosing scope by variable name
    2717                 { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER /*, "ID"*/ ); }
     2722                { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" ); }
    27182723        | '(' paren_type ')'
    27192724                { $$ = $2; }
  • src/ResolvExpr/AdjustExprType.cc

    r0a75b77 rb429026  
    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                 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;
     79                if ( const EqvClass* eqvClass = env.lookup( typeInst->get_name() ) ) {
     80                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
     81                                return new PointerType{ Type::Qualifiers(), typeInst };
    8482                        }
    8583                } else if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
    8684                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
    8785                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
    88                                         PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
    89                                         return pointerType;
     86                                        return new PointerType{ Type::Qualifiers(), typeInst };
    9087                                } // if
    9188                        } // if
  • src/ResolvExpr/AlternativeFinder.cc

    r0a75b77 rb429026  
    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, Expression * member );
     104                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name );
    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                         NameExpr nameExpr( "" );
    310                         addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
     309                        addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
    311310                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->result ) ) {
    312                         NameExpr nameExpr( "" );
    313                         addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
     311                        addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
    314312                } // if
    315313        }
    316314
    317315        template< typename StructOrUnionType >
    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;
     316        void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name ) {
    323317                std::list< Declaration* > members;
    324318                aggInst->lookup( name, members );
     
    472466        }
    473467
    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 
    477468        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
    479469
    480470        void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
     
    487477
    488478        template< typename ForwardIterator, typename OutputIterator >
    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 ) {
     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 ) {
    491480                if ( begin == end ) {
    492481                        if ( newNeed.empty() ) {
     
    506495                                        printAssertionSet( newNeed, std::cerr, 8 );
    507496                                )
    508                                 inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, /*needParents,*/ level+1, indexer, out );
     497                                inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, level+1, indexer, out );
    509498                                return;
    510499                        }
     
    513502                ForwardIterator cur = begin++;
    514503                if ( ! cur->second.isUsed ) {
    515                         inferRecursive( begin, end, newAlt, openVars, decls, newNeed, /*needParents,*/ level, indexer, out );
     504                        inferRecursive( begin, end, newAlt, openVars, decls, newNeed, level, indexer, out );
    516505                        return; // xxx - should this continue? previously this wasn't here, and it looks like it should be
    517506                }
     
    566555                                }
    567556
    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 
    573557                                Expression *varExpr = data.combine( newerAlt.cvtCost );
    574558                                delete varExpr->get_result();
     
    588572                                // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
    589573                                (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
    590                                 inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
     574                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
    591575                        } else {
    592576                                delete adjType;
     
    610594                addToIndexer( have, decls );
    611595                AssertionSet newNeed;
    612                 //AssertionParentSet needParents;
    613596                PRINT(
    614597                        std::cerr << "env is: " << std::endl;
     
    617600                )
    618601
    619                 inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, /*needParents,*/ 0, indexer, out );
     602                inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
    620603//      PRINT(
    621604//          std::cerr << "declaration 14 is ";
     
    10961079                AlternativeFinder funcOpFinder( indexer, env );
    10971080                // it's ok if there aren't any defined function ops
    1098                 funcOpFinder.maybeFind( opExpr);
     1081                funcOpFinder.maybeFind( opExpr );
    10991082                PRINT(
    11001083                        std::cerr << "known function ops:" << std::endl;
     
    11331116                                        }
    11341117                                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->result->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer)
    1135                                         EqvClass eqvClass;
    1136                                         if ( func->env.lookup( typeInst->name, eqvClass ) && eqvClass.type ) {
    1137                                                 if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
     1118                                        if ( const EqvClass *eqvClass = func->env.lookup( typeInst->name ) ) {
     1119                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass->type ) ) {
    11381120                                                        Alternative newFunc( *func );
    11391121                                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );
     
    13501332        }
    13511333
     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
    13521343        void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) {
    13531344                AlternativeFinder funcFinder( indexer, env );
     
    13621353                        // find member of the given type
    13631354                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
    1364                                 addAggMembers( structInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
     1355                                addAggMembers( structInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
    13651356                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
    1366                                 addAggMembers( unionInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
     1357                                addAggMembers( unionInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
    13671358                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
    13681359                                addTupleMembers( tupleType, aggrExpr, cost, agg->env, memberExpr->get_member() );
  • src/ResolvExpr/CastCost.cc

    r0a75b77 rb429026  
    4343        Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    4444                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    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 );
     45                        if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
     46                                if ( eqvClass->type ) {
     47                                        return castCost( src, eqvClass->type, indexer, env );
    5048                                } else {
    5149                                        return Cost::infinity;
    5250                                }
    53                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
     51                        } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) {
    5452                                // all typedefs should be gone by this point
    5553                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
  • src/ResolvExpr/ConversionCost.cc

    r0a75b77 rb429026  
    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;
    4644                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
    47                         if ( env.lookup( destAsTypeInst->name, eqvClass ) ) {
    48                                 if ( eqvClass.type ) {
    49                                         return conversionCost( src, eqvClass.type, indexer, env );
     45                        if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->name ) ) {
     46                                if ( eqvClass->type ) {
     47                                        return conversionCost( src, eqvClass->type, indexer, env );
    5048                                } else {
    5149                                        return Cost::infinity;
    5250                                }
    53                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) {
     51                        } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->name ) ) {
    5452                                PRINT( std::cerr << " found" << std::endl; )
    5553                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
     
    369367
    370368        void ConversionCost::postvisit( TypeInstType *inst ) {
    371                 EqvClass eqvClass;
    372                 NamedTypeDecl *namedType;
    373                 if ( env.lookup( inst->name, eqvClass ) ) {
    374                         cost = costFunc( eqvClass.type, dest, indexer, env );
     369                if ( const EqvClass *eqvClass = env.lookup( inst->name ) ) {
     370                        cost = costFunc( eqvClass->type, dest, indexer, env );
    375371                } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) {
    376372                        if ( inst->name == destAsInst->name ) {
    377373                                cost = Cost::zero;
    378374                        }
    379                 } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) {
     375                } else if ( NamedTypeDecl *namedType = indexer.lookupType( inst->name ) ) {
    380376                        TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    381377                        // all typedefs should be gone by this point
  • src/ResolvExpr/Occurs.cc

    r0a75b77 rb429026  
    3838
    3939        Occurs::Occurs( std::string varName, const TypeEnvironment & env ) : result( false ), tenv( env ) {
    40                 EqvClass eqvClass;
    41                 if ( tenv.lookup( varName, eqvClass ) ) {
    42                         eqvVars = eqvClass.vars;
     40                if ( const EqvClass *eqvClass = tenv.lookup( varName ) ) {
     41                        eqvVars = eqvClass->vars;
    4342                } else {
    4443                        eqvVars.insert( varName );
     
    4746
    4847        void Occurs::previsit( TypeInstType * typeInst ) {
    49                 EqvClass eqvClass;
    50 ///   std::cerr << "searching for vars: ";
     48                ///   std::cerr << "searching for vars: ";
    5149///   std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::cerr, " " ) );
    5250///   std::cerr << std::endl;
    5351                if ( eqvVars.find( typeInst->get_name() ) != eqvVars.end() ) {
    5452                        result = true;
    55                 } else if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
    56                         if ( eqvClass.type ) {
     53                } else if ( const EqvClass *eqvClass = tenv.lookup( typeInst->get_name() ) ) {
     54                        if ( eqvClass->type ) {
    5755///       std::cerr << typeInst->get_name() << " is bound to";
    5856///       eqvClass.type->print( std::cerr );
    5957///       std::cerr << std::endl;
    60                                 eqvClass.type->accept( *visitor );
     58                                eqvClass->type->accept( *visitor );
    6159                        } // if
    6260                } // if
  • src/ResolvExpr/PolyCost.cc

    r0a75b77 rb429026  
    3939
    4040        void PolyCost::previsit(TypeInstType * typeInst) {
    41                 EqvClass eqvClass;
    42                 if ( tenv.lookup( typeInst->name, eqvClass ) ) {
    43                         if ( eqvClass.type ) {
    44                                 if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass.type ) ) {
     41                if ( const EqvClass *eqvClass = tenv.lookup( typeInst->name ) ) {
     42                        if ( eqvClass->type ) {
     43                                if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass->type ) ) {
    4544                                        if ( indexer.lookupType( otherTypeInst->name ) ) {
    4645                                                // bound to opaque type
  • src/ResolvExpr/PtrsAssignable.cc

    r0a75b77 rb429026  
    5151                // std::cerr << "assignable: " << src << " | " << dest << std::endl;
    5252                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    53                         EqvClass eqvClass;
    54                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
    55                                 return ptrsAssignable( src, eqvClass.type, env );
     53                        if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
     54                                return ptrsAssignable( src, eqvClass->type, env );
    5655                        } // if
    5756                } // if
     
    9594        void PtrsAssignable::postvisit(  __attribute__((unused)) TraitInstType *inst ) {}
    9695        void PtrsAssignable::postvisit( TypeInstType *inst ) {
    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 );
     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                        }
    101101                } // if
    102102        }
  • src/ResolvExpr/PtrsCastable.cc

    r0a75b77 rb429026  
    5757                                return -1;
    5858                        } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( src ) ) {
    59                                 EqvClass eqvClass;
    6059                                if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
    6160                                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
     
    6463                                                } // if
    6564                                        } //if
    66                                 } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
    67                                         if ( eqvClass.data.kind == TypeDecl::Ftype ) {
     65                                } else if ( const EqvClass *eqvClass = env.lookup( typeInst->get_name() ) ) {
     66                                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
    6867                                                return -1;
    6968                                        } // if
     
    7978        int ptrsCastable( Type *src, Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
    8079                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    81                         EqvClass eqvClass;
    82                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
     80                        if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
    8381                                // xxx - should this be ptrsCastable?
    84                                 return ptrsAssignable( src, eqvClass.type, env );
     82                                return ptrsAssignable( src, eqvClass->type, env );
    8583                        } // if
    8684                } // if
  • src/ResolvExpr/TypeEnvironment.cc

    r0a75b77 rb429026  
    1717#include <algorithm>                   // for copy, set_intersection
    1818#include <iterator>                    // for ostream_iterator, insert_iterator
    19 #include <utility>                     // for pair
     19#include <utility>                     // for pair, move
    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 ) {
    4650                dest.vars = src.vars;
    47                 dest.type = maybeClone( src.type );
     51                dest.type = maybeClone( ty );
    4852                dest.allowWidening = src.allowWidening;
    4953                dest.data = src.data;
     
    5559        EqvClass::EqvClass( const EqvClass &other ) {
    5660                initialize( other, *this );
     61        }
     62
     63        EqvClass::EqvClass( const EqvClass &other, const Type *ty ) {
     64                initialize( other, *this, ty );
    5765        }
    5866
     
    8290        }
    8391
    84         bool TypeEnvironment::lookup( const std::string &var, EqvClass &eqvClass ) const {
     92        const EqvClass* TypeEnvironment::lookup( const std::string &var ) const {
    8593                for ( std::list< EqvClass >::const_iterator i = env.begin(); i != env.end(); ++i ) {
    8694                        if ( i->vars.find( var ) != i->vars.end() ) {
    8795///       std::cout << var << " is in class ";
    8896///       i->print( std::cout );
    89                                 eqvClass = *i;
    90                                 return true;
     97                                return &*i;
    9198                        }
    9299///     std::cout << var << " is not in class ";
    93100///     i->print( std::cout );
    94101                } // for
    95                 return false;
     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 ); }
     114                        i = next;
     115                }
    96116        }
    97117
    98118        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
    108                         i = next;
    109                 } // while
    110                 env.insert( env.end(), 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) );
    111126        }
    112127
  • src/ResolvExpr/TypeEnvironment.h

    r0a75b77 rb429026  
    7373
    7474                void initialize( const EqvClass &src, EqvClass &dest );
     75                void initialize( const EqvClass &src, EqvClass &dest, const Type *ty );
    7576                EqvClass();
    7677                EqvClass( const EqvClass &other );
     78                EqvClass( const EqvClass &other, const Type *ty );
    7779                EqvClass &operator=( const EqvClass &other );
    7880                ~EqvClass();
     
    8284        class TypeEnvironment {
    8385          public:
    84                 bool lookup( const std::string &var, EqvClass &eqvClass ) const;
     86                const EqvClass* lookup( const std::string &var ) const;
    8587                void add( const EqvClass &eqvClass );
     88                void add( EqvClass &&eqvClass  );
    8689                void add( const Type::ForallList &tyDecls );
    8790                void add( const TypeSubstitution & sub );
  • src/ResolvExpr/Unify.cc

    r0a75b77 rb429026  
    2020#include <set>                    // for set
    2121#include <string>                 // for string, operator==, operator!=, bas...
    22 #include <utility>                // for pair
     22#include <utility>                // for pair, move
    2323
    2424#include "Common/PassVisitor.h"   // for PassVisitor
     
    166166                        return false;
    167167                } // if
    168                 EqvClass curClass;
    169                 if ( env.lookup( typeInst->get_name(), curClass ) ) {
    170                         if ( curClass.type ) {
     168                if ( const EqvClass *curClass = env.lookup( typeInst->get_name() ) ) {
     169                        if ( curClass->type ) {
    171170                                Type *common = 0;
    172171                                // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
    173                                 std::unique_ptr< Type > newType( curClass.type->clone() );
     172                                std::unique_ptr< Type > newType( curClass->type->clone() );
    174173                                newType->get_qualifiers() = typeInst->get_qualifiers();
    175                                 if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) {
     174                                if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
    176175                                        if ( common ) {
    177176                                                common->get_qualifiers() = Type::Qualifiers();
    178                                                 delete curClass.type;
    179                                                 curClass.type = common;
    180                                                 env.add( curClass );
     177                                                env.add( EqvClass{ *curClass, common } );
    181178                                        } // if
    182179                                        return true;
     
    185182                                } // if
    186183                        } else {
    187                                 curClass.type = other->clone();
    188                                 curClass.type->get_qualifiers() = Type::Qualifiers();
    189                                 curClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
    190                                 env.add( curClass );
     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) );
    191188                        } // if
    192189                } else {
     
    204201        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 ) {
    205202                bool result = true;
    206                 EqvClass class1, class2;
    207                 bool hasClass1 = false, hasClass2 = false;
     203                const EqvClass *class1 = env.lookup( var1->get_name() );
     204                const EqvClass *class2 = env.lookup( var2->get_name() );
    208205                bool widen1 = false, widen2 = false;
    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 ) ) {
     206                Type *type1 = nullptr, *type2 = nullptr;
     207
     208                if ( class1 ) {
     209                        if ( class1->type ) {
     210                                if ( occurs( class1->type, var2->get_name(), env ) ) {
    215211                                        return false;
    216212                                } // if
    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 ) ) {
     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 ) ) {
    225220                                        return false;
    226221                                } // if
    227                                 type2 = class2.type->clone();
    228                         } // if
    229                         widen2 = widenMode.widenSecond && class2.allowWidening;
     222                                type2 = class2->type->clone();
     223                        } // if
     224                        widen2 = widenMode.widenSecond && class2->allowWidening;
    230225                } // if
    231226
     
    235230                        Type *common = 0;
    236231                        if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, newWidenMode, indexer, common ) ) {
    237                                 class1.vars.insert( class2.vars.begin(), class2.vars.end() );
    238                                 class1.allowWidening = widen1 && widen2;
     232                                EqvClass newClass1 = *class1;
     233                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
     234                                newClass1.allowWidening = widen1 && widen2;
    239235                                if ( common ) {
    240236                                        common->get_qualifiers() = Type::Qualifiers();
    241                                         delete class1.type;
    242                                         class1.type = common;
     237                                        delete newClass1.type;
     238                                        newClass1.type = common;
    243239                                } // if
    244                                 env.add( class1 );
     240                                env.add( std::move(newClass1) );
    245241                        } else {
    246242                                result = false;
    247243                        } // if
    248                 } else if ( hasClass1 && hasClass2 ) {
     244                } else if ( class1 && class2 ) {
    249245                        if ( type1 ) {
    250                                 class1.vars.insert( class2.vars.begin(), class2.vars.end() );
    251                                 class1.allowWidening = widen1;
    252                                 env.add( class1 );
     246                                EqvClass newClass1 = *class1;
     247                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
     248                                newClass1.allowWidening = widen1;
     249                                env.add( std::move(newClass1) );
    253250                        } else {
    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 );
     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) );
    266266                } else {
    267267                        EqvClass newClass;
     
    539539                void premutate( TypeInstType * ) { visit_children = false; }
    540540                Type * postmutate( TypeInstType * typeInst ) {
    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                                         }
     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();
    549546                                }
    550547                        }
  • src/benchmark/Makefile.am

    r0a75b77 rb429026  
    9696        ctxswitch-cfa_coroutine.run     \
    9797        ctxswitch-cfa_thread.run        \
     98        ctxswitch-cfa_thread2.run       \
    9899        ctxswitch-upp_coroutine.run     \
    99100        ctxswitch-upp_thread.run        \
     101        -ctxswitch-kos_fibre.run        \
     102        -ctxswitch-kos_fibre2.run       \
    100103        ctxswitch-goroutine.run         \
    101104        ctxswitch-java_thread.run
    102105
     106ctxswitch-pthread$(EXEEXT):
     107        @@BACKEND_CC@ ctxswitch/pthreads.c     -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     108
    103109ctxswitch-cfa_coroutine$(EXEEXT):
    104         @${CC}        ctxswitch/cfa_cor.c   -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     110        @${CC}        ctxswitch/cfa_cor.c      -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    105111
    106112ctxswitch-cfa_thread$(EXEEXT):
    107         @${CC}        ctxswitch/cfa_thrd.c  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     113        @${CC}        ctxswitch/cfa_thrd.c     -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     114
     115ctxswitch-cfa_thread2$(EXEEXT):
     116        @${CC}        ctxswitch/cfa_thrd2.c    -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    108117
    109118ctxswitch-upp_coroutine$(EXEEXT):
    110         @u++          ctxswitch/upp_cor.cc  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     119        @u++          ctxswitch/upp_cor.cc     -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    111120
    112121ctxswitch-upp_thread$(EXEEXT):
    113         @u++          ctxswitch/upp_thrd.cc -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    114 
    115 ctxswitch-pthread$(EXEEXT):
    116         @@BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     122        @u++          ctxswitch/upp_thrd.cc    -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     123
     124ctxswitch-kos_fibre$(EXEEXT):
     125        @${CXX}       ctxswitch/kos_fibre.cpp  -DBENCH_N=50000000  -I. -I/home/tdelisle/software/KOS/src/ -g -O2 -lfibre -lpthread -lrt
     126
     127ctxswitch-kos_fibre2$(EXEEXT):
     128        @${CXX}       ctxswitch/kos_fibre2.cpp -DBENCH_N=50000000  -I. -I/home/tdelisle/software/KOS/src/ -g -O2 -lfibre -lpthread -lrt
    117129
    118130ctxswitch-goroutine$(EXEEXT):
  • src/benchmark/Makefile.in

    r0a75b77 rb429026  
    509509        ctxswitch-cfa_coroutine.run     \
    510510        ctxswitch-cfa_thread.run        \
     511        ctxswitch-cfa_thread2.run       \
    511512        ctxswitch-upp_coroutine.run     \
    512513        ctxswitch-upp_thread.run        \
     514        -ctxswitch-kos_fibre.run        \
     515        -ctxswitch-kos_fibre2.run       \
    513516        ctxswitch-goroutine.run         \
    514517        ctxswitch-java_thread.run
    515518
     519ctxswitch-pthread$(EXEEXT):
     520        @@BACKEND_CC@ ctxswitch/pthreads.c     -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     521
    516522ctxswitch-cfa_coroutine$(EXEEXT):
    517         @${CC}        ctxswitch/cfa_cor.c   -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     523        @${CC}        ctxswitch/cfa_cor.c      -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    518524
    519525ctxswitch-cfa_thread$(EXEEXT):
    520         @${CC}        ctxswitch/cfa_thrd.c  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     526        @${CC}        ctxswitch/cfa_thrd.c     -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     527
     528ctxswitch-cfa_thread2$(EXEEXT):
     529        @${CC}        ctxswitch/cfa_thrd2.c    -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    521530
    522531ctxswitch-upp_coroutine$(EXEEXT):
    523         @u++          ctxswitch/upp_cor.cc  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     532        @u++          ctxswitch/upp_cor.cc     -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    524533
    525534ctxswitch-upp_thread$(EXEEXT):
    526         @u++          ctxswitch/upp_thrd.cc -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    527 
    528 ctxswitch-pthread$(EXEEXT):
    529         @@BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     535        @u++          ctxswitch/upp_thrd.cc    -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     536
     537ctxswitch-kos_fibre$(EXEEXT):
     538        @${CXX}       ctxswitch/kos_fibre.cpp  -DBENCH_N=50000000  -I. -I/home/tdelisle/software/KOS/src/ -g -O2 -lfibre -lpthread -lrt
     539
     540ctxswitch-kos_fibre2$(EXEEXT):
     541        @${CXX}       ctxswitch/kos_fibre2.cpp -DBENCH_N=50000000  -I. -I/home/tdelisle/software/KOS/src/ -g -O2 -lfibre -lpthread -lrt
    530542
    531543ctxswitch-goroutine$(EXEEXT):
     
    682694
    683695compile-io$(EXEEXT):
    684         @${CC} -quiet -fsyntax-only -w ../tests/io.c                                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     696        @${CC} -quiet -fsyntax-only -w ../tests/io1.c                           @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    685697
    686698compile-monitor$(EXEEXT):
    687         @${CC} -quiet -fsyntax-only -w ../tests/concurrent/monitor.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     699        @${CC} -quiet -fsyntax-only -w ../tests/concurrent/monitor.c    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    688700
    689701compile-operators$(EXEEXT):
     
    694706
    695707compile-typeof$(EXEEXT):
    696         @${CC} -quiet -fsyntax-only -w ../tests/typeof.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     708        @${CC} -quiet -fsyntax-only -w ../tests/typeof.c                        @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    697709
    698710# Tell versions [3.59,3.63) of GNU make to not export all variables.
  • src/libcfa/iostream

    r0a75b77 rb429026  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Apr 28 13:08:24 2018
    13 // Update Count     : 152
     12// Last Modified On : Sat Jun  2 08:07:55 2018
     13// Update Count     : 153
    1414//
    1515
     
    5656// implement writable for intrinsic types
    5757
    58 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, _Bool );
     58forall( dtype ostype | ostream( ostype ) ) {
     59        ostype & ?|?( ostype &, _Bool );
    5960
    60 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, char );
    61 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, signed char );
    62 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned char );
     61        ostype & ?|?( ostype &, char );
     62        ostype & ?|?( ostype &, signed char );
     63        ostype & ?|?( ostype &, unsigned char );
    6364
    64 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, short int );
    65 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned short int );
    66 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, int );
    67 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned int );
    68 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long int );
    69 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long long int );
    70 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned long int );
    71 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned long long int );
     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 );
    7273
    73 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, float ); // FIX ME: should not be required
    74 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, double );
    75 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long double );
     74        ostype & ?|?( ostype &, float ); // FIX ME: should not be required
     75        ostype & ?|?( ostype &, double );
     76        ostype & ?|?( ostype &, long double );
    7677
    77 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, float _Complex );
    78 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, double _Complex );
    79 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long double _Complex );
     78        ostype & ?|?( ostype &, float _Complex );
     79        ostype & ?|?( ostype &, double _Complex );
     80        ostype & ?|?( ostype &, long double _Complex );
    8081
    81 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const char * );
    82 //forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const char16_t * );
     82        ostype & ?|?( ostype &, const char * );
     83        // ostype & ?|?( ostype &, const char16_t * );
    8384#if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
    84 //forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const char32_t * );
     85        // ostype & ?|?( ostype &, const char32_t * );
    8586#endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
    86 //forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const wchar_t * );
    87 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const void * );
     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
    88100
    89101// tuples
    90102forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } )
    91103ostype & ?|?( ostype & os, T arg, Params rest );
    92 
    93 // manipulators
    94 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, ostype & (*)( ostype & ) );
    95 forall( dtype ostype | ostream( ostype ) ) ostype & endl( ostype & );
    96 forall( dtype ostype | ostream( ostype ) ) ostype & sep( ostype & );
    97 forall( dtype ostype | ostream( ostype ) ) ostype & sepTuple( ostype & );
    98 forall( dtype ostype | ostream( ostype ) ) ostype & sepOn( ostype & );
    99 forall( dtype ostype | ostream( ostype ) ) ostype & sepOff( ostype & );
    100 forall( dtype ostype | ostream( ostype ) ) ostype & sepDisable( ostype & );
    101 forall( dtype ostype | ostream( ostype ) ) ostype & sepEnable( ostype & );
    102104
    103105// writes the range [begin, end) to the given stream
     
    124126}; // readable
    125127
    126 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, _Bool & );
     128forall( dtype istype | istream( istype ) ) {
     129        istype & ?|?( istype &, _Bool & );
    127130
    128 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, char & );
    129 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, signed char & );
    130 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned char & );
     131        istype & ?|?( istype &, char & );
     132        istype & ?|?( istype &, signed char & );
     133        istype & ?|?( istype &, unsigned char & );
    131134
    132 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, short int & );
    133 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned short int & );
    134 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, int & );
    135 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned int & );
    136 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long int & );
    137 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long long int & );
    138 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned long int & );
    139 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned long long int & );
     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 & );
    140143
    141 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, float & );
    142 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, double & );
    143 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long double & );
     144        istype & ?|?( istype &, float & );
     145        istype & ?|?( istype &, double & );
     146        istype & ?|?( istype &, long double & );
    144147
    145 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, float _Complex & );
    146 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, double _Complex & );
    147 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long double _Complex & );
     148        istype & ?|?( istype &, float _Complex & );
     149        istype & ?|?( istype &, double _Complex & );
     150        istype & ?|?( istype &, long double _Complex & );
    148151
    149 // manipulators
    150 forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, istype & (*)( istype & ) );
    151 forall( dtype istype | istream( istype ) ) istype & endl( istype & is );
     152        // manipulators
     153        istype & ?|?( istype &, istype & (*)( istype & ) );
     154        istype & endl( istype & is );
     155} // distribution
    152156
    153157struct _Istream_cstrUC { char * s; };
  • src/libcfa/iostream.c

    r0a75b77 rb429026  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Apr 28 13:08:25 2018
    13 // Update Count     : 469
     12// Last Modified On : Sat Jun  2 08:24:56 2018
     13// Update Count     : 471
    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 forall( dtype ostype | ostream( ostype ) )
    36 ostype & ?|?( ostype & os, char ch ) {
    37         fmt( os, "%c", ch );
    38         if ( ch == '\n' ) setNL( os, true );
    39         sepOff( os );
    40         return os;
    41 } // ?|?
    42 
    43 forall( dtype ostype | ostream( ostype ) )
    44 ostype & ?|?( ostype & os, signed char c ) {
    45         if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    46         fmt( os, "%hhd", c );
    47         return os;
    48 } // ?|?
    49 
    50 forall( dtype ostype | ostream( ostype ) )
    51 ostype & ?|?( ostype & os, unsigned char c ) {
    52         if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    53         fmt( os, "%hhu", c );
    54         return os;
    55 } // ?|?
    56 
    57 forall( dtype ostype | ostream( ostype ) )
    58 ostype & ?|?( ostype & os, short int si ) {
    59         if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    60         fmt( os, "%hd", si );
    61         return os;
    62 } // ?|?
    63 
    64 forall( dtype ostype | ostream( ostype ) )
    65 ostype & ?|?( 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 
    71 forall( dtype ostype | ostream( ostype ) )
    72 ostype & ?|?( ostype & os, int i ) {
    73         if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    74         fmt( os, "%d", i );
    75         return os;
    76 } // ?|?
    77 
    78 forall( dtype ostype | ostream( ostype ) )
    79 ostype & ?|?( ostype & os, unsigned int ui ) {
    80         if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    81         fmt( os, "%u", ui );
    82         return os;
    83 } // ?|?
    84 
    85 forall( dtype ostype | ostream( ostype ) )
    86 ostype & ?|?( ostype & os, long int li ) {
    87         if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    88         fmt( os, "%ld", li );
    89         return os;
    90 } // ?|?
    91 
    92 forall( dtype ostype | ostream( ostype ) )
    93 ostype & ?|?( 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 
    99 forall( dtype ostype | ostream( ostype ) )
    100 ostype & ?|?( 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 
    106 forall( dtype ostype | ostream( ostype ) )
    107 ostype & ?|?( 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 
    113 forall( dtype ostype | ostream( ostype ) )
    114 ostype & ?|?( ostype & os, float f ) {
    115         if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    116         fmt( os, "%g", f );
    117         return os;
    118 } // ?|?
    119 
    120 forall( dtype ostype | ostream( ostype ) )
    121 ostype & ?|?( 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 
    127 forall( dtype ostype | ostream( ostype ) )
    128 ostype & ?|?( 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 
    134 forall( dtype ostype | ostream( ostype ) )
    135 ostype & ?|?( 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 
    141 forall( dtype ostype | ostream( ostype ) )
    142 ostype & ?|?( 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 
    148 forall( dtype ostype | ostream( ostype ) )
    149 ostype & ?|?( 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 
    155 forall( dtype ostype | ostream( ostype ) )
    156 ostype & ?|?( 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 ) {
     28forall( 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 );
     38                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//      } // ?|?
     182
     183// #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//      } // ?|?
     189// #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
     190
     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 ) {
    187228                sepOn( os );
    188         } else {
     229                return os;
     230        } // sepOn
     231
     232        ostype & sepOff( ostype & os ) {
    189233                sepOff( os );
    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 // } // ?|?
    201 
    202 // #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
    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 // } // ?|?
    209 // #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
    210 
    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 
    218 forall( dtype ostype | ostream( ostype ) )
    219 ostype & ?|?( ostype & os, const void * p ) {
    220         if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    221         fmt( os, "%p", p );
    222         return os;
    223 } // ?|?
     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
    224247
    225248
     
    234257} // ?|?
    235258
    236 
    237 // manipulators
    238 forall( dtype ostype | ostream( ostype ) )
    239 ostype & ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
    240         return manip( os );
    241 } // ?|?
    242 
    243 forall( dtype ostype | ostream( ostype ) )
    244 ostype & sep( ostype & os ) {
    245         os | sepGet( os );
    246         return os;
    247 } // sep
    248 
    249 forall( dtype ostype | ostream( ostype ) )
    250 ostype & sepTuple( ostype & os ) {
    251         os | sepGetTuple( os );
    252         return os;
    253 } // sepTuple
    254 
    255 forall( dtype ostype | ostream( ostype ) )
    256 ostype & 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 
    264 forall( dtype ostype | ostream( ostype ) )
    265 ostype & sepOn( ostype & os ) {
    266         sepOn( os );
    267         return os;
    268 } // sepOn
    269 
    270 forall( dtype ostype | ostream( ostype ) )
    271 ostype & sepOff( ostype & os ) {
    272         sepOff( os );
    273         return os;
    274 } // sepOff
    275 
    276 forall( dtype ostype | ostream( ostype ) )
    277 ostype & sepEnable( ostype & os ) {
    278         sepEnable( os );
    279         return os;
    280 } // sepEnable
    281 
    282 forall( dtype ostype | ostream( ostype ) )
    283 ostype & sepDisable( ostype & os ) {
    284         sepDisable( os );
    285         return os;
    286 } // sepDisable
    287 
    288259//---------------------------------------
    289260
     261// writes the range [begin, end) to the given stream
    290262forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
    291263void write( iterator_type begin, iterator_type end, ostype & os ) {
     
    302274//---------------------------------------
    303275
    304 forall( dtype istype | istream( istype ) )
    305 istype & ?|?( istype & is, _Bool & b ) {
    306         char val[6];
    307         fmt( is, "%5s", val );
    308         if ( strcmp( val, "true" ) == 0 ) b = true;
    309         else if ( strcmp( val, "false" ) == 0 ) b = false;
    310         else {
    311                 fprintf( stderr, "invalid _Bool constant\n" );
    312                 abort();
    313         } // if
    314         return is;
    315 } // ?|?
    316 
    317 forall( dtype istype | istream( istype ) )
    318 istype & ?|?( istype & is, char & c ) {
    319         fmt( is, "%c", &c );                                                            // must pass pointer through varg to fmt
    320         return is;
    321 } // ?|?
    322 
    323 forall( dtype istype | istream( istype ) )
    324 istype & ?|?( istype & is, signed char & sc ) {
    325         fmt( is, "%hhd", &sc );
    326         return is;
    327 } // ?|?
    328 
    329 forall( dtype istype | istream( istype ) )
    330 istype & ?|?( istype & is, unsigned char & usc ) {
    331         fmt( is, "%hhu", &usc );
    332         return is;
    333 } // ?|?
    334 
    335 forall( dtype istype | istream( istype ) )
    336 istype & ?|?( istype & is, short int & si ) {
    337         fmt( is, "%hd", &si );
    338         return is;
    339 } // ?|?
    340 
    341 forall( dtype istype | istream( istype ) )
    342 istype & ?|?( istype & is, unsigned short int & usi ) {
    343         fmt( is, "%hu", &usi );
    344         return is;
    345 } // ?|?
    346 
    347 forall( dtype istype | istream( istype ) )
    348 istype & ?|?( istype & is, int & i ) {
    349         fmt( is, "%d", &i );
    350         return is;
    351 } // ?|?
    352 
    353 forall( dtype istype | istream( istype ) )
    354 istype & ?|?( istype & is, unsigned int & ui ) {
    355         fmt( is, "%u", &ui );
    356         return is;
    357 } // ?|?
    358 
    359 forall( dtype istype | istream( istype ) )
    360 istype & ?|?( istype & is, long int & li ) {
    361         fmt( is, "%ld", &li );
    362         return is;
    363 } // ?|?
    364 
    365 forall( dtype istype | istream( istype ) )
    366 istype & ?|?( istype & is, unsigned long int & ulli ) {
    367         fmt( is, "%lu", &ulli );
    368         return is;
    369 } // ?|?
    370 
    371 forall( dtype istype | istream( istype ) )
    372 istype & ?|?( istype & is, long long int & lli ) {
    373         fmt( is, "%lld", &lli );
    374         return is;
    375 } // ?|?
    376 
    377 forall( dtype istype | istream( istype ) )
    378 istype & ?|?( istype & is, unsigned long long int & ulli ) {
    379         fmt( is, "%llu", &ulli );
    380         return is;
    381 } // ?|?
    382 
    383 
    384 forall( dtype istype | istream( istype ) )
    385 istype & ?|?( istype & is, float & f ) {
    386         fmt( is, "%f", &f );
    387         return is;
    388 } // ?|?
    389 
    390 forall( dtype istype | istream( istype ) )
    391 istype & ?|?( istype & is, double & d ) {
    392         fmt( is, "%lf", &d );
    393         return is;
    394 } // ?|?
    395 
    396 forall( dtype istype | istream( istype ) )
    397 istype & ?|?( istype & is, long double & ld ) {
    398         fmt( is, "%Lf", &ld );
    399         return is;
    400 } // ?|?
    401 
    402 
    403 forall( dtype istype | istream( istype ) )
    404 istype & ?|?( 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 
    411 forall( dtype istype | istream( istype ) )
    412 istype & ?|?( 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 
    419 forall( dtype istype | istream( istype ) )
    420 istype & ?|?( 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 
    427 forall( dtype istype | istream( istype ) )
    428 istype & ?|?( istype & is, istype & (* manip)( istype & ) ) {
    429         return manip( is );
    430 } // ?|?
    431 
    432 forall( dtype istype | istream( istype ) )
    433 istype & endl( istype & is ) {
    434         fmt( is, "%*[ \t\f\n\r\v]" );                                           // ignore whitespace
    435         return is;
    436 } // endl
     276forall( 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
    437393
    438394_Istream_cstrUC cstr( char * str ) { return (_Istream_cstrUC){ str }; }
  • src/libcfa/rational

    r0a75b77 rb429026  
    1212// Created On       : Wed Apr  6 17:56:25 2016
    1313// Last Modified By : Peter A. Buhr
    14 // Last Modified On : Wed Dec  6 23:12:53 2017
    15 // Update Count     : 97
     14// Last Modified On : Sat Jun  2 09:10:01 2018
     15// Update Count     : 105
    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 ) ) {
     49        struct Rational {
     50                RationalImpl numerator, denominator;                    // invariant: denominator > 0
     51        }; // Rational
    5252
    53 // constructors
     53        // constructors
    5454
    55 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    56 void ?{}( Rational(RationalImpl) & r );
     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 );
    5760
    58 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    59 void ?{}( Rational(RationalImpl) & r, RationalImpl n );
     61        // numerator/denominator getter
    6062
    61 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    62 void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d );
     63        RationalImpl numerator( Rational(RationalImpl) r );
     64        RationalImpl denominator( Rational(RationalImpl) r );
     65        [ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src );
    6366
    64 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    65 void ?{}( Rational(RationalImpl) & r, zero_t );
     67        // numerator/denominator setter
    6668
    67 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    68 void ?{}( Rational(RationalImpl) & r, one_t );
     69        RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n );
     70        RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d );
    6971
    70 // numerator/denominator getter
     72        // comparison
    7173
    72 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    73 RationalImpl numerator( Rational(RationalImpl) r );
     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 );
    7480
    75 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    76 RationalImpl denominator( Rational(RationalImpl) r );
     81        // arithmetic
    7782
    78 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    79 [ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src );
     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 );
    8089
    81 // numerator/denominator setter
     90        // I/O
     91        forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } )
     92        istype & ?|?( istype &, Rational(RationalImpl) & );
    8293
    83 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    84 RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n );
    85 
    86 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    87 RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d );
    88 
    89 // comparison
    90 
    91 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    92 int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    93 
    94 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    95 int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    96 
    97 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    98 int ?<?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    99 
    100 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    101 int ?<=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    102 
    103 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    104 int ?>?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    105 
    106 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    107 int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    108 
    109 // arithmetic
    110 
    111 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    112 Rational(RationalImpl) +?( Rational(RationalImpl) r );
    113 
    114 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    115 Rational(RationalImpl) -?( Rational(RationalImpl) r );
    116 
    117 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    118 Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    119 
    120 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    121 Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    122 
    123 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    124 Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    125 
    126 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    127 Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     94        forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } )
     95        ostype & ?|?( ostype &, Rational(RationalImpl ) );
     96} // distribution
    12897
    12998// conversion
     
    133102Rational(RationalImpl) narrow( double f, RationalImpl md );
    134103
    135 // I/O
    136 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    137 forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } )
    138 istype & ?|?( istype &, Rational(RationalImpl) & );
    139 
    140 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    141 forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } )
    142 ostype & ?|?( ostype &, Rational(RationalImpl ) );
    143 
    144104// Local Variables: //
    145105// mode: c //
  • src/libcfa/rational.c

    r0a75b77 rb429026  
    1010// Created On       : Wed Apr  6 17:54:28 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec  6 23:13:58 2017
    13 // Update Count     : 156
     12// Last Modified On : Sat Jun  2 09:24:33 2018
     13// Update Count     : 162
    1414//
    1515
     
    1818#include "stdlib"
    1919
    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
    24 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    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 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    36 static 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 
    48 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    49 void ?{}( Rational(RationalImpl) & r ) {
    50         r{ (RationalImpl){0}, (RationalImpl){1} };
    51 } // rational
    52 
    53 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    54 void ?{}( Rational(RationalImpl) & r, RationalImpl n ) {
    55         r{ n, (RationalImpl){1} };
    56 } // rational
    57 
    58 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    59 void ?{}( 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 
    68 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    69 RationalImpl numerator( Rational(RationalImpl) r ) {
    70         return r.numerator;
    71 } // numerator
    72 
    73 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    74 RationalImpl denominator( Rational(RationalImpl) r ) {
    75         return r.denominator;
    76 } // denominator
    77 
    78 forall( 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 
    85 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    86 RationalImpl 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 
    94 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    95 RationalImpl 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 
    106 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    107 int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    108         return l.numerator * r.denominator == l.denominator * r.numerator;
    109 } // ?==?
    110 
    111 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    112 int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    113         return ! ( l == r );
    114 } // ?!=?
    115 
    116 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    117 int ?<?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    118         return l.numerator * r.denominator < l.denominator * r.numerator;
    119 } // ?<?
    120 
    121 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    122 int ?<=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    123         return l.numerator * r.denominator <= l.denominator * r.numerator;
    124 } // ?<=?
    125 
    126 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    127 int ?>?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    128         return ! ( l <= r );
    129 } // ?>?
    130 
    131 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    132 int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    133         return ! ( l < r );
    134 } // ?>=?
    135 
    136 
    137 // arithmetic
    138 
    139 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    140 Rational(RationalImpl) +?( Rational(RationalImpl) r ) {
    141         Rational(RationalImpl) t = { r.numerator, r.denominator };
    142         return t;
    143 } // +?
    144 
    145 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    146 Rational(RationalImpl) -?( Rational(RationalImpl) r ) {
    147         Rational(RationalImpl) t = { -r.numerator, r.denominator };
    148         return t;
    149 } // -?
    150 
    151 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    152 Rational(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 
    162 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    163 Rational(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 
    173 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    174 Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    175         Rational(RationalImpl) t = { l.numerator * r.numerator, l.denominator * r.denominator };
    176         return t;
    177 } // ?*?
    178 
    179 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    180 Rational(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 
     20forall( 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
    189182
    190183// conversion
     
    195188} // widen
    196189
    197 // http://www.ics.uci.edu/~eppstein/numth/frap.c
    198190forall( otype RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); RationalImpl convert( double ); } )
    199191Rational(RationalImpl) narrow( double f, RationalImpl md ) {
     192        // http://www.ics.uci.edu/~eppstein/numth/frap.c
    200193        if ( md <= (RationalImpl){1} ) {                                        // maximum fractional digits too small?
    201194                return (Rational(RationalImpl)){ convert( f ), (RationalImpl){1}}; // truncate fraction
     
    224217} // narrow
    225218
    226 
    227 // I/O
    228 
    229 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    230 forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } )
    231 istype & ?|?( 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 
    240 forall( otype RationalImpl | arithmetic( RationalImpl ) )
    241 forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } )
    242 ostype & ?|?( ostype & os, Rational(RationalImpl ) r ) {
    243         return os | r.numerator | '/' | r.denominator;
    244 } // ?|?
    245 
    246219// Local Variables: //
    247220// tab-width: 4 //
  • src/libcfa/stdlib

    r0a75b77 rb429026  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed May 16 07:53:10 2018
    13 // Update Count     : 300
     12// Last Modified On : Sat Jun  2 08:46:35 2018
     13// Update Count     : 306
    1414//
    1515
    1616#pragma once
    1717
    18 #include <stdlib.h>                                                                             // strto*, *abs
     18#include <stdlib.h>                                                                             // allocation, strto*, *abs
     19extern "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"
    1924
    2025//---------------------------------------
     
    2732//---------------------------------------
    2833
    29 // C dynamic allocation
    3034static inline forall( dtype T | sized(T) ) {
     35        // C dynamic allocation
     36
    3137        T * malloc( void ) {
    3238                // printf( "* malloc\n" );
     
    5157        } // realloc
    5258
    53         extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void *
    5459        T * memalign( size_t align ) {
    5560                //printf( "X4\n" );
     
    5762        } // memalign
    5863
    59         extern "C" { void * aligned_alloc( size_t align, size_t size ); } // use default C routine for void *
    6064        T * aligned_alloc( size_t align ) {
    6165                //printf( "X5\n" );
     
    7074
    7175        // Cforall dynamic allocation
    72         extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
    7376
    7477        T * alloc( void ) {
     
    103106forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
    104107
    105 static 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
    109 static 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 
    115 static 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
    119 static 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
    127 static 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
    131 extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
    132 static 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
    138 static 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
    142 static 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
     108
     109static 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
     134static 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
     150static 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
    146163
    147164// allocation/deallocation and constructor/destructor, non-array types
     
    189206//---------------------------------------
    190207
    191 forall( otype E | { int ?<?( E, E ); } )
    192 E * bsearch( E key, const E * vals, size_t dim );
    193 
    194 forall( otype E | { int ?<?( E, E ); } )
    195 size_t bsearch( E key, const E * vals, size_t dim );
    196 
    197 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    198 E * bsearch( K key, const E * vals, size_t dim );
    199 
    200 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    201 size_t bsearch( K key, const E * vals, size_t dim );
    202 
    203 
    204 forall( otype E | { int ?<?( E, E ); } )
    205 E * bsearchl( E key, const E * vals, size_t dim );
    206 
    207 forall( otype E | { int ?<?( E, E ); } )
    208 size_t bsearchl( E key, const E * vals, size_t dim );
    209 
    210 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    211 E * bsearchl( K key, const E * vals, size_t dim );
    212 
    213 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    214 size_t bsearchl( K key, const E * vals, size_t dim );
    215 
    216 
    217 forall( otype E | { int ?<?( E, E ); } )
    218 E * bsearchu( E key, const E * vals, size_t dim );
    219 
    220 forall( otype E | { int ?<?( E, E ); } )
    221 size_t bsearchu( E key, const E * vals, size_t dim );
    222 
    223 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    224 E * bsearchu( K key, const E * vals, size_t dim );
    225 
    226 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    227 size_t bsearchu( K key, const E * vals, size_t dim );
    228 
    229 
    230 forall( otype E | { int ?<?( E, E ); } )
    231 void qsort( E * vals, size_t dim );
     208forall( 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
     219forall( 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
    232227
    233228//---------------------------------------
  • src/libcfa/stdlib.c

    r0a75b77 rb429026  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jan  3 08:29:29 2018
    13 // Update Count     : 444
     12// Last Modified On : Sat Jun  2 06:15:05 2018
     13// Update Count     : 448
    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 forall( otype E | { int ?<?( E, E ); } )
    141 size_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 
    146 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    147 E * 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 
    154 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    155 size_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 
    161 forall( otype E | { int ?<?( E, E ); } )
    162 size_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 
    175 forall( otype E | { int ?<?( E, E ); } )
    176 E * 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 
    181 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    182 size_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 
    195 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    196 E * 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 
    202 forall( otype E | { int ?<?( E, E ); } )
    203 size_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 
    216 forall( otype E | { int ?<?( E, E ); } )
    217 E * 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 
    222 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    223 size_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 
    236 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    237 E * 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 
    243 forall( otype E | { int ?<?( E, E ); } )
    244 void 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
     132forall( 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
     191forall( 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
    250240
    251241//---------------------------------------
  • src/tests/.expect/ifcond.txt

    r0a75b77 rb429026  
    22x != 0 && y != 0 correct
    33x == y correct
     4s.i < 4 correct
  • src/tests/.expect/literals.x64.txt

    r0a75b77 rb429026  
    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_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);
    24 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_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));
    25 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_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);
    26 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_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);
    27 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_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);
    28 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_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);
    29 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_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);
    30 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_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);
    31 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_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);
     23void *___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));
     24void *__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);
     25void *__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);
     26void *__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);
     27void *__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);
     28void *__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);
     29void *__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);
     30void *__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);
     31void *___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);
    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

    r0a75b77 rb429026  
    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_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);
    24 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_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));
    25 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_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);
    26 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_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);
    27 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_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);
    28 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_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);
    29 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_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);
    30 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_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);
    31 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_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);
     23void *___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));
     24void *__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);
     25void *__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);
     26void *__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);
     27void *__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);
     28void *__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);
     29void *__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);
     30void *__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);
     31void *___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);
    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

    r0a75b77 rb429026  
    99// Author           : Peter A. Buhr
    1010// Created On       : Sat Aug 26 10:13:11 2017
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Fri Sep 01 15:22:19 2017
    13 // Update Count     : 14
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jun  2 09:55:02 2018
     13// Update Count     : 15
    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
    4248} // main
    4349
  • src/tests/preempt_longrun/processor.c

    r0a75b77 rb429026  
    2323                p[pi] = new();
    2424        }
     25        for ( int pi = 0; pi < 15; pi++ ) {
     26                delete( p[pi] );
     27        }
    2528}
Note: See TracChangeset for help on using the changeset viewer.