Index: src/Parser/TypedefTable.cc =================================================================== --- src/Parser/TypedefTable.cc (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/Parser/TypedefTable.cc (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:20:13 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed May 30 18:04:38 2018 -// Update Count : 148 +// Last Modified On : Fri Jun 1 16:54:18 2018 +// Update Count : 155 // @@ -54,19 +54,19 @@ void TypedefTable::makeTypedef( const string & name ) { if ( ! typedefTable.exists( name ) ) { - typedefTable.addToEnclosingScope( name, TYPEDEFname /*, "MTD"*/ ); + typedefTable.addToEnclosingScope( name, TYPEDEFname, "MTD" ); } // if } // TypedefTable::makeTypedef -void TypedefTable::addToScope( const std::string & identifier, int kind /*, const char * locn*/ ) { +void TypedefTable::addToScope( const std::string & identifier, int kind, const char * locn __attribute__((unused)) ) { auto scope = kindTable.currentScope(); - debugPrint( cerr << "Adding at " /* << locn */ << " " << identifier << " as kind " << kind << " scope " << scope << endl ); + debugPrint( cerr << "Adding at " << locn << " " << identifier << " as kind " << kind << " scope " << scope << endl ); auto ret = kindTable.insertAt( scope, identifier, kind ); if ( ! ret.second ) ret.first->second = kind; // exists => update } // TypedefTable::addToScope -void TypedefTable::addToEnclosingScope( const std::string & identifier, int kind /*, const char * locn*/ ) { +void TypedefTable::addToEnclosingScope( const std::string & identifier, int kind, const char * locn __attribute__((unused)) ) { assert( kindTable.currentScope() >= 1 ); auto scope = kindTable.currentScope() - 1; - debugPrint( cerr << "Adding2 at " /* << locn */ << " " << identifier << " as kind " << kind << " scope " << scope << endl ); + debugPrint( cerr << "Adding+1 at " << locn << " " << identifier << " as kind " << kind << " scope " << scope << endl ); auto ret = kindTable.insertAt( scope, identifier, kind ); if ( ! ret.second ) ret.first->second = kind; // exists => update Index: src/Parser/TypedefTable.h =================================================================== --- src/Parser/TypedefTable.h (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/Parser/TypedefTable.h (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:24:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed May 30 17:02:49 2018 -// Update Count : 82 +// Last Modified On : Thu May 31 23:23:47 2018 +// Update Count : 83 // @@ -32,6 +32,6 @@ void changeKind( const std::string & identifier, int kind ); void makeTypedef( const std::string & name ); - void addToScope( const std::string & identifier, int kind /*, const char **/ ); - void addToEnclosingScope( const std::string & identifier, int kind /*, const char */ ); + void addToScope( const std::string & identifier, int kind, const char * ); + void addToEnclosingScope( const std::string & identifier, int kind, const char * ); void enterScope(); Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/Parser/parser.yy (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu May 31 15:11:40 2018 -// Update Count : 3444 +// Last Modified On : Fri Jun 1 17:59:57 2018 +// Update Count : 3476 // @@ -304,5 +304,5 @@ %type enumerator_value_opt -%type exception_declaration external_definition external_definition_list external_definition_list_opt +%type exception_declaration external_definition external_definition_list external_definition_list_no_pop_push external_definition_list_opt %type field_declaration field_declaration_list_opt field_declarator_opt field_declaring_list @@ -644,5 +644,4 @@ // semantics checks, e.g., ++3, 3--, *3, &&3 | constant - { $$ = $1; } | string_literal { $$ = new ExpressionNode( $1 ); } @@ -988,5 +987,4 @@ { $$ = new StatementNode( build_if( $3, $5, $7 ) ); } ; - if_control_expression: @@ -1383,5 +1381,4 @@ cfa_function_declaration: // CFA cfa_function_specifier - { $$ = $1; } | type_qualifier_list cfa_function_specifier { $$ = $2->addQualifiers( $1 ); } @@ -1440,15 +1437,15 @@ TYPEDEF cfa_variable_specifier { - typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname /*, "1"*/ ); + typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "1" ); $$ = $2->addTypedef(); } | TYPEDEF cfa_function_specifier { - typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname /*, "2"*/ ); + typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "2" ); $$ = $2->addTypedef(); } | cfa_typedef_declaration pop ',' push no_attr_identifier { - typedefTable.addToEnclosingScope( *$5, TYPEDEFname /*, "3"*/ ); + typedefTable.addToEnclosingScope( *$5, TYPEDEFname, "3" ); $$ = $1->appendList( $1->cloneType( $5 ) ); } @@ -1461,25 +1458,25 @@ TYPEDEF type_specifier declarator { - typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname /*, "4"*/ ); + typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" ); $$ = $3->addType( $2 )->addTypedef(); } | typedef_declaration pop ',' push declarator { - typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname /*, "5"*/ ); + typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname, "5" ); $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() ); } | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 ) { - typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname /*, "6"*/ ); + typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" ); $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef(); } | type_specifier TYPEDEF declarator { - typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname /*, "7"*/ ); + typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "7" ); $$ = $3->addType( $1 )->addTypedef(); } | type_specifier TYPEDEF type_qualifier_list declarator { - typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname /*, "8"*/ ); + typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" ); $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 ); } @@ -1937,5 +1934,4 @@ { $$ = nullptr; } | bit_subrange_size - { $$ = $1; } ; @@ -2187,5 +2183,4 @@ type_parameter_list: // CFA type_parameter - { $$ = $1; } | type_parameter_list ',' type_parameter { $$ = $1->appendList( $3 ); } @@ -2201,5 +2196,5 @@ type_parameter: // CFA type_class no_attr_identifier_or_type_name - { typedefTable.addToScope( *$2, TYPEDEFname /*, "9"*/ ); } + { typedefTable.addToScope( *$2, TYPEDEFname, "9" ); } type_initializer_opt assertion_list_opt { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); } @@ -2270,10 +2265,10 @@ no_attr_identifier_or_type_name { - typedefTable.addToEnclosingScope( *$1, TYPEDEFname /*, "10"*/ ); + typedefTable.addToEnclosingScope( *$1, TYPEDEFname, "10" ); $$ = DeclarationNode::newTypeDecl( $1, 0 ); } | no_attr_identifier_or_type_name '(' type_parameter_list ')' { - typedefTable.addToEnclosingScope( *$1, TYPEGENname /*, "11"*/ ); + typedefTable.addToEnclosingScope( *$1, TYPEGENname, "11" ); $$ = DeclarationNode::newTypeDecl( $1, $3 ); } @@ -2330,8 +2325,22 @@ ; + // SKULLDUGGERY: Declarations in extern "X" and distribution need to be added to the current lexical scope. + // However, external_definition_list creates a new scope around each external_definition, but the pop loses all the + // types in the extern "X" and distribution at the end of the block. This version of external_definition_list does + + // not do push/pop for declarations at the level of the extern "X" and distribution block. Any recursive uses of + // external_definition_list within the extern "X" and distribution block correctly pushes/pops for that scope level. +external_definition_list_no_pop_push: + external_definition + | external_definition_list_no_pop_push + { forall = xxx; } + external_definition + { $$ = $1 ? $1->appendList( $3 ) : $3; } + ; + external_definition_list_opt: // empty { $$ = nullptr; } - | external_definition_list + | external_definition_list_no_pop_push ; @@ -2339,4 +2348,9 @@ declaration | external_function_definition + | EXTENSION external_definition // GCC, multiple __extension__ allowed, meaning unknown + { + distExt( $2 ); // mark all fields in list + $$ = $2; + } | ASM '(' string_literal ')' ';' // GCC, global assembler statement { @@ -2348,22 +2362,13 @@ linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 ); } - // SKULLDUGGERY: Declarations in extern "X" need to be added to the current lexical scope. However, - // external_definition_list_opt creates a new scope that loses the types at the end of the extern block. The - // correction is a pop/push (reverse order) to undo the push/pop from external_definition_list_opt. This - // trick works for nested extern "X"s, as each one undoes itself in the nesting. - '{' pop external_definition_list_opt push '}' + '{' external_definition_list_opt '}' { linkage = linkageStack.top(); linkageStack.pop(); - $$ = $6; - } - | EXTENSION external_definition // GCC, multiple __extension__ allowed, meaning unknown - { - distExt( $2 ); // mark all fields in list - $$ = $2; + $$ = $5; } | type_qualifier_list { if ( $1->type->forall ) xxx = forall = true; } // remember generic type - '{' external_definition_list push '}' // CFA, namespace + '{' external_definition_list_opt '}' // CFA, namespace { for ( DeclarationNode * iter = $4; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) { @@ -2378,5 +2383,5 @@ | declaration_qualifier_list { if ( $1->type->forall ) xxx = forall = true; } // remember generic type - '{' external_definition_list '}' // CFA, namespace + '{' external_definition_list_opt '}' // CFA, namespace { for ( DeclarationNode * iter = $4; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) { @@ -2394,5 +2399,5 @@ if ( $2->type->forall ) xxx = forall = true; // remember generic type } - '{' external_definition_list '}' // CFA, namespace + '{' external_definition_list_opt '}' // CFA, namespace { for ( DeclarationNode * iter = $5; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) { @@ -2715,5 +2720,5 @@ typedef // hide type name in enclosing scope by variable name - { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER /*, "ID"*/ ); } + { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" ); } | '(' paren_type ')' { $$ = $2; } Index: src/ResolvExpr/AdjustExprType.cc =================================================================== --- src/ResolvExpr/AdjustExprType.cc (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/ResolvExpr/AdjustExprType.cc (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -66,5 +66,5 @@ Type * AdjustExprType::postmutate( ArrayType * arrayType ) { - PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base ); + PointerType *pointerType = new PointerType{ arrayType->get_qualifiers(), arrayType->base }; arrayType->base = nullptr; delete arrayType; @@ -73,19 +73,16 @@ Type * AdjustExprType::postmutate( FunctionType * functionType ) { - return new PointerType( Type::Qualifiers(), functionType ); + return new PointerType{ Type::Qualifiers(), functionType }; } Type * AdjustExprType::postmutate( TypeInstType * typeInst ) { - EqvClass eqvClass; - if ( env.lookup( typeInst->get_name(), eqvClass ) ) { - if ( eqvClass.data.kind == TypeDecl::Ftype ) { - PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst ); - return pointerType; + if ( const EqvClass* eqvClass = env.lookup( typeInst->get_name() ) ) { + if ( eqvClass->data.kind == TypeDecl::Ftype ) { + return new PointerType{ Type::Qualifiers(), typeInst }; } } else if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) { if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) { if ( tyDecl->get_kind() == TypeDecl::Ftype ) { - PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst ); - return pointerType; + return new PointerType{ Type::Qualifiers(), typeInst }; } // if } // if Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/ResolvExpr/AlternativeFinder.cc (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -102,5 +102,5 @@ void addAnonConversions( const Alternative & alt ); /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member - template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); + template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name ); /// Adds alternatives for member expressions where the left side has tuple type void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); @@ -307,18 +307,12 @@ if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->result ) ) { - NameExpr nameExpr( "" ); - addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr ); + addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" ); } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->result ) ) { - NameExpr nameExpr( "" ); - addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr ); + addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" ); } // if } template< typename StructOrUnionType > - void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { - // by this point, member must be a name expr - NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ); - if ( ! nameExpr ) return; - const std::string & name = nameExpr->name; + void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name ) { std::list< Declaration* > members; aggInst->lookup( name, members ); @@ -472,9 +466,5 @@ } - // /// Map of declaration uniqueIds (intended to be the assertions in an AssertionSet) to their parents and the number of times they've been included - //typedef std::unordered_map< UniqueId, std::unordered_map< UniqueId, unsigned > > AssertionParentSet; - static const int recursionLimit = /*10*/ 4; ///< Limit to depth of recursion satisfaction - //static const unsigned recursionParentLimit = 1; ///< Limit to the number of times an assertion can recursively use itself void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) { @@ -487,6 +477,5 @@ template< typename ForwardIterator, typename OutputIterator > - void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, /*const AssertionParentSet &needParents,*/ - int level, const SymTab::Indexer &indexer, OutputIterator out ) { + 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 ) { if ( begin == end ) { if ( newNeed.empty() ) { @@ -506,5 +495,5 @@ printAssertionSet( newNeed, std::cerr, 8 ); ) - inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, /*needParents,*/ level+1, indexer, out ); + inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, level+1, indexer, out ); return; } @@ -513,5 +502,5 @@ ForwardIterator cur = begin++; if ( ! cur->second.isUsed ) { - inferRecursive( begin, end, newAlt, openVars, decls, newNeed, /*needParents,*/ level, indexer, out ); + inferRecursive( begin, end, newAlt, openVars, decls, newNeed, level, indexer, out ); return; // xxx - should this continue? previously this wasn't here, and it looks like it should be } @@ -566,9 +555,4 @@ } - //AssertionParentSet newNeedParents( needParents ); - // skip repeatingly-self-recursive assertion satisfaction - // DOESN'T WORK: grandchild nodes conflict with their cousins - //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue; - Expression *varExpr = data.combine( newerAlt.cvtCost ); delete varExpr->get_result(); @@ -588,5 +572,5 @@ // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr ); - inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out ); + inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out ); } else { delete adjType; @@ -610,5 +594,4 @@ addToIndexer( have, decls ); AssertionSet newNeed; - //AssertionParentSet needParents; PRINT( std::cerr << "env is: " << std::endl; @@ -617,5 +600,5 @@ ) - inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, /*needParents,*/ 0, indexer, out ); + inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out ); // PRINT( // std::cerr << "declaration 14 is "; @@ -1096,5 +1079,5 @@ AlternativeFinder funcOpFinder( indexer, env ); // it's ok if there aren't any defined function ops - funcOpFinder.maybeFind( opExpr); + funcOpFinder.maybeFind( opExpr ); PRINT( std::cerr << "known function ops:" << std::endl; @@ -1133,7 +1116,6 @@ } } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->result->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer) - EqvClass eqvClass; - if ( func->env.lookup( typeInst->name, eqvClass ) && eqvClass.type ) { - if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) { + if ( const EqvClass *eqvClass = func->env.lookup( typeInst->name ) ) { + if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass->type ) ) { Alternative newFunc( *func ); referenceToRvalueConversion( newFunc.expr, newFunc.cost ); @@ -1350,4 +1332,13 @@ } + namespace { + /// Gets name from untyped member expression (member must be NameExpr) + const std::string& get_member_name( UntypedMemberExpr *memberExpr ) { + NameExpr * nameExpr = dynamic_cast< NameExpr * >( memberExpr->get_member() ); + assert( nameExpr ); + return nameExpr->get_name(); + } + } + void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) { AlternativeFinder funcFinder( indexer, env ); @@ -1362,7 +1353,7 @@ // find member of the given type if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) { - addAggMembers( structInst, aggrExpr, cost, agg->env, memberExpr->get_member() ); + addAggMembers( structInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) ); } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) { - addAggMembers( unionInst, aggrExpr, cost, agg->env, memberExpr->get_member() ); + addAggMembers( unionInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) ); } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) { addTupleMembers( tupleType, aggrExpr, cost, agg->env, memberExpr->get_member() ); Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/ResolvExpr/CastCost.cc (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -43,13 +43,11 @@ Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) { - EqvClass eqvClass; - NamedTypeDecl *namedType; - if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) { - if ( eqvClass.type ) { - return castCost( src, eqvClass.type, indexer, env ); + if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->get_name() ) ) { + if ( eqvClass->type ) { + return castCost( src, eqvClass->type, indexer, env ); } else { return Cost::infinity; } - } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) { + } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) { // all typedefs should be gone by this point TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType ); Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/ResolvExpr/ConversionCost.cc (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -42,14 +42,12 @@ Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) { - EqvClass eqvClass; - NamedTypeDecl *namedType; PRINT( std::cerr << "type inst " << destAsTypeInst->name; ) - if ( env.lookup( destAsTypeInst->name, eqvClass ) ) { - if ( eqvClass.type ) { - return conversionCost( src, eqvClass.type, indexer, env ); + if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->name ) ) { + if ( eqvClass->type ) { + return conversionCost( src, eqvClass->type, indexer, env ); } else { return Cost::infinity; } - } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) { + } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->name ) ) { PRINT( std::cerr << " found" << std::endl; ) TypeDecl *type = dynamic_cast< TypeDecl* >( namedType ); @@ -369,13 +367,11 @@ void ConversionCost::postvisit( TypeInstType *inst ) { - EqvClass eqvClass; - NamedTypeDecl *namedType; - if ( env.lookup( inst->name, eqvClass ) ) { - cost = costFunc( eqvClass.type, dest, indexer, env ); + if ( const EqvClass *eqvClass = env.lookup( inst->name ) ) { + cost = costFunc( eqvClass->type, dest, indexer, env ); } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) { if ( inst->name == destAsInst->name ) { cost = Cost::zero; } - } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) { + } else if ( NamedTypeDecl *namedType = indexer.lookupType( inst->name ) ) { TypeDecl *type = dynamic_cast< TypeDecl* >( namedType ); // all typedefs should be gone by this point Index: src/ResolvExpr/Occurs.cc =================================================================== --- src/ResolvExpr/Occurs.cc (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/ResolvExpr/Occurs.cc (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -38,7 +38,6 @@ Occurs::Occurs( std::string varName, const TypeEnvironment & env ) : result( false ), tenv( env ) { - EqvClass eqvClass; - if ( tenv.lookup( varName, eqvClass ) ) { - eqvVars = eqvClass.vars; + if ( const EqvClass *eqvClass = tenv.lookup( varName ) ) { + eqvVars = eqvClass->vars; } else { eqvVars.insert( varName ); @@ -47,16 +46,15 @@ void Occurs::previsit( TypeInstType * typeInst ) { - EqvClass eqvClass; -/// std::cerr << "searching for vars: "; + /// std::cerr << "searching for vars: "; /// std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::cerr, " " ) ); /// std::cerr << std::endl; if ( eqvVars.find( typeInst->get_name() ) != eqvVars.end() ) { result = true; - } else if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) { - if ( eqvClass.type ) { + } else if ( const EqvClass *eqvClass = tenv.lookup( typeInst->get_name() ) ) { + if ( eqvClass->type ) { /// std::cerr << typeInst->get_name() << " is bound to"; /// eqvClass.type->print( std::cerr ); /// std::cerr << std::endl; - eqvClass.type->accept( *visitor ); + eqvClass->type->accept( *visitor ); } // if } // if Index: src/ResolvExpr/PolyCost.cc =================================================================== --- src/ResolvExpr/PolyCost.cc (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/ResolvExpr/PolyCost.cc (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -39,8 +39,7 @@ void PolyCost::previsit(TypeInstType * typeInst) { - EqvClass eqvClass; - if ( tenv.lookup( typeInst->name, eqvClass ) ) { - if ( eqvClass.type ) { - if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass.type ) ) { + if ( const EqvClass *eqvClass = tenv.lookup( typeInst->name ) ) { + if ( eqvClass->type ) { + if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass->type ) ) { if ( indexer.lookupType( otherTypeInst->name ) ) { // bound to opaque type Index: src/ResolvExpr/PtrsAssignable.cc =================================================================== --- src/ResolvExpr/PtrsAssignable.cc (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/ResolvExpr/PtrsAssignable.cc (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -51,7 +51,6 @@ // std::cerr << "assignable: " << src << " | " << dest << std::endl; if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) { - EqvClass eqvClass; - if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) { - return ptrsAssignable( src, eqvClass.type, env ); + if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) { + return ptrsAssignable( src, eqvClass->type, env ); } // if } // if @@ -95,8 +94,9 @@ void PtrsAssignable::postvisit( __attribute__((unused)) TraitInstType *inst ) {} void PtrsAssignable::postvisit( TypeInstType *inst ) { - EqvClass eqvClass; - if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) { - // T * = S * for any S depends on the type bound to T - result = ptrsAssignable( eqvClass.type, dest, env ); + if ( const EqvClass *eqvClass = env.lookup( inst->get_name() ) ) { + if ( eqvClass->type ) { + // T * = S * for any S depends on the type bound to T + result = ptrsAssignable( eqvClass->type, dest, env ); + } } // if } Index: src/ResolvExpr/PtrsCastable.cc =================================================================== --- src/ResolvExpr/PtrsCastable.cc (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/ResolvExpr/PtrsCastable.cc (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -57,5 +57,4 @@ return -1; } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( src ) ) { - EqvClass eqvClass; if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) { if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) { @@ -64,6 +63,6 @@ } // if } //if - } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) { - if ( eqvClass.data.kind == TypeDecl::Ftype ) { + } else if ( const EqvClass *eqvClass = env.lookup( typeInst->get_name() ) ) { + if ( eqvClass->data.kind == TypeDecl::Ftype ) { return -1; } // if @@ -79,8 +78,7 @@ int ptrsCastable( Type *src, Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ) { if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) { - EqvClass eqvClass; - if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) { + if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) { // xxx - should this be ptrsCastable? - return ptrsAssignable( src, eqvClass.type, env ); + return ptrsAssignable( src, eqvClass->type, env ); } // if } // if Index: src/ResolvExpr/TypeEnvironment.cc =================================================================== --- src/ResolvExpr/TypeEnvironment.cc (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/ResolvExpr/TypeEnvironment.cc (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -17,5 +17,5 @@ #include // for copy, set_intersection #include // for ostream_iterator, insert_iterator -#include // for pair +#include // for pair, move #include "Common/utility.h" // for maybeClone @@ -44,6 +44,10 @@ void EqvClass::initialize( const EqvClass &src, EqvClass &dest ) { + initialize( src, dest, src.type ); + } + + void EqvClass::initialize( const EqvClass &src, EqvClass &dest, const Type *ty ) { dest.vars = src.vars; - dest.type = maybeClone( src.type ); + dest.type = maybeClone( ty ); dest.allowWidening = src.allowWidening; dest.data = src.data; @@ -55,4 +59,8 @@ EqvClass::EqvClass( const EqvClass &other ) { initialize( other, *this ); + } + + EqvClass::EqvClass( const EqvClass &other, const Type *ty ) { + initialize( other, *this, ty ); } @@ -82,31 +90,38 @@ } - bool TypeEnvironment::lookup( const std::string &var, EqvClass &eqvClass ) const { + const EqvClass* TypeEnvironment::lookup( const std::string &var ) const { for ( std::list< EqvClass >::const_iterator i = env.begin(); i != env.end(); ++i ) { if ( i->vars.find( var ) != i->vars.end() ) { /// std::cout << var << " is in class "; /// i->print( std::cout ); - eqvClass = *i; - return true; + return &*i; } /// std::cout << var << " is not in class "; /// i->print( std::cout ); } // for - return false; + return nullptr; + } + + /// Removes any class from env that intersects eqvClass + void filterOverlappingClasses( std::list &env, const EqvClass &eqvClass ) { + for ( auto i = env.begin(); i != env.end(); ) { + auto next = i; + ++next; + std::set intersection; + std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(), + std::inserter( intersection, intersection.begin() ) ); + if ( ! intersection.empty() ) { env.erase( i ); } + i = next; + } } void TypeEnvironment::add( const EqvClass &eqvClass ) { - std::list< EqvClass >::iterator i = env.begin(); - while ( i != env.end() ) { - std::list< EqvClass >::iterator next = i; - next++; - std::set< std::string > intersection; - std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(), std::inserter( intersection, intersection.begin() ) ); - if ( ! intersection.empty() ) { - env.erase( i ); - } // if - i = next; - } // while - env.insert( env.end(), eqvClass ); + filterOverlappingClasses( env, eqvClass ); + env.push_back( eqvClass ); + } + + void TypeEnvironment::add( EqvClass &&eqvClass ) { + filterOverlappingClasses( env, eqvClass ); + env.push_back( std::move(eqvClass) ); } Index: src/ResolvExpr/TypeEnvironment.h =================================================================== --- src/ResolvExpr/TypeEnvironment.h (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/ResolvExpr/TypeEnvironment.h (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -73,6 +73,8 @@ void initialize( const EqvClass &src, EqvClass &dest ); + void initialize( const EqvClass &src, EqvClass &dest, const Type *ty ); EqvClass(); EqvClass( const EqvClass &other ); + EqvClass( const EqvClass &other, const Type *ty ); EqvClass &operator=( const EqvClass &other ); ~EqvClass(); @@ -82,6 +84,7 @@ class TypeEnvironment { public: - bool lookup( const std::string &var, EqvClass &eqvClass ) const; + const EqvClass* lookup( const std::string &var ) const; void add( const EqvClass &eqvClass ); + void add( EqvClass &&eqvClass ); void add( const Type::ForallList &tyDecls ); void add( const TypeSubstitution & sub ); Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/ResolvExpr/Unify.cc (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -20,5 +20,5 @@ #include // for set #include // for string, operator==, operator!=, bas... -#include // for pair +#include // for pair, move #include "Common/PassVisitor.h" // for PassVisitor @@ -166,17 +166,14 @@ return false; } // if - EqvClass curClass; - if ( env.lookup( typeInst->get_name(), curClass ) ) { - if ( curClass.type ) { + if ( const EqvClass *curClass = env.lookup( typeInst->get_name() ) ) { + if ( curClass->type ) { Type *common = 0; // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to - std::unique_ptr< Type > newType( curClass.type->clone() ); + std::unique_ptr< Type > newType( curClass->type->clone() ); newType->get_qualifiers() = typeInst->get_qualifiers(); - if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) { + if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) { if ( common ) { common->get_qualifiers() = Type::Qualifiers(); - delete curClass.type; - curClass.type = common; - env.add( curClass ); + env.add( EqvClass{ *curClass, common } ); } // if return true; @@ -185,8 +182,8 @@ } // if } else { - curClass.type = other->clone(); - curClass.type->get_qualifiers() = Type::Qualifiers(); - curClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond; - env.add( curClass ); + EqvClass newClass { *curClass, other }; + newClass.type->get_qualifiers() = Type::Qualifiers(); + newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond; + env.add( std::move(newClass) ); } // if } else { @@ -204,28 +201,26 @@ 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 ) { bool result = true; - EqvClass class1, class2; - bool hasClass1 = false, hasClass2 = false; + const EqvClass *class1 = env.lookup( var1->get_name() ); + const EqvClass *class2 = env.lookup( var2->get_name() ); bool widen1 = false, widen2 = false; - Type *type1 = 0, *type2 = 0; - - if ( env.lookup( var1->get_name(), class1 ) ) { - hasClass1 = true; - if ( class1.type ) { - if ( occurs( class1.type, var2->get_name(), env ) ) { + Type *type1 = nullptr, *type2 = nullptr; + + if ( class1 ) { + if ( class1->type ) { + if ( occurs( class1->type, var2->get_name(), env ) ) { return false; } // if - type1 = class1.type->clone(); - } // if - widen1 = widenMode.widenFirst && class1.allowWidening; - } // if - if ( env.lookup( var2->get_name(), class2 ) ) { - hasClass2 = true; - if ( class2.type ) { - if ( occurs( class2.type, var1->get_name(), env ) ) { + type1 = class1->type->clone(); + } // if + widen1 = widenMode.widenFirst && class1->allowWidening; + } // if + if ( class2 ) { + if ( class2->type ) { + if ( occurs( class2->type, var1->get_name(), env ) ) { return false; } // if - type2 = class2.type->clone(); - } // if - widen2 = widenMode.widenSecond && class2.allowWidening; + type2 = class2->type->clone(); + } // if + widen2 = widenMode.widenSecond && class2->allowWidening; } // if @@ -235,33 +230,38 @@ Type *common = 0; if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, newWidenMode, indexer, common ) ) { - class1.vars.insert( class2.vars.begin(), class2.vars.end() ); - class1.allowWidening = widen1 && widen2; + EqvClass newClass1 = *class1; + newClass1.vars.insert( class2->vars.begin(), class2->vars.end() ); + newClass1.allowWidening = widen1 && widen2; if ( common ) { common->get_qualifiers() = Type::Qualifiers(); - delete class1.type; - class1.type = common; + delete newClass1.type; + newClass1.type = common; } // if - env.add( class1 ); + env.add( std::move(newClass1) ); } else { result = false; } // if - } else if ( hasClass1 && hasClass2 ) { + } else if ( class1 && class2 ) { if ( type1 ) { - class1.vars.insert( class2.vars.begin(), class2.vars.end() ); - class1.allowWidening = widen1; - env.add( class1 ); + EqvClass newClass1 = *class1; + newClass1.vars.insert( class2->vars.begin(), class2->vars.end() ); + newClass1.allowWidening = widen1; + env.add( std::move(newClass1) ); } else { - class2.vars.insert( class1.vars.begin(), class1.vars.end() ); - class2.allowWidening = widen2; - env.add( class2 ); - } // if - } else if ( hasClass1 ) { - class1.vars.insert( var2->get_name() ); - class1.allowWidening = widen1; - env.add( class1 ); - } else if ( hasClass2 ) { - class2.vars.insert( var1->get_name() ); - class2.allowWidening = widen2; - env.add( class2 ); + EqvClass newClass2 = *class2; + newClass2.vars.insert( class1->vars.begin(), class1->vars.end() ); + newClass2.allowWidening = widen2; + env.add( std::move(newClass2) ); + } // if + } else if ( class1 ) { + EqvClass newClass1 = *class1; + newClass1.vars.insert( var2->get_name() ); + newClass1.allowWidening = widen1; + env.add( std::move(newClass1) ); + } else if ( class2 ) { + EqvClass newClass2 = *class2; + newClass2.vars.insert( var1->get_name() ); + newClass2.allowWidening = widen2; + env.add( std::move(newClass2) ); } else { EqvClass newClass; @@ -539,12 +539,9 @@ void premutate( TypeInstType * ) { visit_children = false; } Type * postmutate( TypeInstType * typeInst ) { - EqvClass eqvClass; - if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) { - if ( eqvClass.data.kind == TypeDecl::Ttype ) { - // expand ttype parameter into its actual type - if ( eqvClass.type ) { - delete typeInst; - return eqvClass.type->clone(); - } + if ( const EqvClass *eqvClass = tenv.lookup( typeInst->get_name() ) ) { + // expand ttype parameter into its actual type + if ( eqvClass->data.kind == TypeDecl::Ttype && eqvClass->type ) { + delete typeInst; + return eqvClass->type->clone(); } } Index: src/libcfa/iostream =================================================================== --- src/libcfa/iostream (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/libcfa/iostream (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Apr 28 13:08:24 2018 -// Update Count : 152 +// Last Modified On : Sat Jun 2 08:07:55 2018 +// Update Count : 153 // @@ -56,48 +56,50 @@ // implement writable for intrinsic types -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, _Bool ); +forall( dtype ostype | ostream( ostype ) ) { + ostype & ?|?( ostype &, _Bool ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, char ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, signed char ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned char ); + ostype & ?|?( ostype &, char ); + ostype & ?|?( ostype &, signed char ); + ostype & ?|?( ostype &, unsigned char ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, short int ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned short int ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, int ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned int ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long int ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long long int ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned long int ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, unsigned long long int ); + ostype & ?|?( ostype &, short int ); + ostype & ?|?( ostype &, unsigned short int ); + ostype & ?|?( ostype &, int ); + ostype & ?|?( ostype &, unsigned int ); + ostype & ?|?( ostype &, long int ); + ostype & ?|?( ostype &, long long int ); + ostype & ?|?( ostype &, unsigned long int ); + ostype & ?|?( ostype &, unsigned long long int ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, float ); // FIX ME: should not be required -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, double ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long double ); + ostype & ?|?( ostype &, float ); // FIX ME: should not be required + ostype & ?|?( ostype &, double ); + ostype & ?|?( ostype &, long double ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, float _Complex ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, double _Complex ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, long double _Complex ); + ostype & ?|?( ostype &, float _Complex ); + ostype & ?|?( ostype &, double _Complex ); + ostype & ?|?( ostype &, long double _Complex ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const char * ); -//forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const char16_t * ); + ostype & ?|?( ostype &, const char * ); + // ostype & ?|?( ostype &, const char16_t * ); #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous -//forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const char32_t * ); + // ostype & ?|?( ostype &, const char32_t * ); #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) -//forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const wchar_t * ); -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, const void * ); + // ostype & ?|?( ostype &, const wchar_t * ); + ostype & ?|?( ostype &, const void * ); + + // manipulators + ostype & ?|?( ostype &, ostype & (*)( ostype & ) ); + ostype & endl( ostype & ); + ostype & sep( ostype & ); + ostype & sepTuple( ostype & ); + ostype & sepOn( ostype & ); + ostype & sepOff( ostype & ); + ostype & sepDisable( ostype & ); + ostype & sepEnable( ostype & ); +} // distribution // tuples forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } ) ostype & ?|?( ostype & os, T arg, Params rest ); - -// manipulators -forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, ostype & (*)( ostype & ) ); -forall( dtype ostype | ostream( ostype ) ) ostype & endl( ostype & ); -forall( dtype ostype | ostream( ostype ) ) ostype & sep( ostype & ); -forall( dtype ostype | ostream( ostype ) ) ostype & sepTuple( ostype & ); -forall( dtype ostype | ostream( ostype ) ) ostype & sepOn( ostype & ); -forall( dtype ostype | ostream( ostype ) ) ostype & sepOff( ostype & ); -forall( dtype ostype | ostream( ostype ) ) ostype & sepDisable( ostype & ); -forall( dtype ostype | ostream( ostype ) ) ostype & sepEnable( ostype & ); // writes the range [begin, end) to the given stream @@ -124,30 +126,32 @@ }; // readable -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, _Bool & ); +forall( dtype istype | istream( istype ) ) { + istype & ?|?( istype &, _Bool & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, char & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, signed char & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned char & ); + istype & ?|?( istype &, char & ); + istype & ?|?( istype &, signed char & ); + istype & ?|?( istype &, unsigned char & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, short int & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned short int & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, int & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned int & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long int & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long long int & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned long int & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, unsigned long long int & ); + istype & ?|?( istype &, short int & ); + istype & ?|?( istype &, unsigned short int & ); + istype & ?|?( istype &, int & ); + istype & ?|?( istype &, unsigned int & ); + istype & ?|?( istype &, long int & ); + istype & ?|?( istype &, long long int & ); + istype & ?|?( istype &, unsigned long int & ); + istype & ?|?( istype &, unsigned long long int & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, float & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, double & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long double & ); + istype & ?|?( istype &, float & ); + istype & ?|?( istype &, double & ); + istype & ?|?( istype &, long double & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, float _Complex & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, double _Complex & ); -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, long double _Complex & ); + istype & ?|?( istype &, float _Complex & ); + istype & ?|?( istype &, double _Complex & ); + istype & ?|?( istype &, long double _Complex & ); -// manipulators -forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, istype & (*)( istype & ) ); -forall( dtype istype | istream( istype ) ) istype & endl( istype & is ); + // manipulators + istype & ?|?( istype &, istype & (*)( istype & ) ); + istype & endl( istype & is ); +} // distribution struct _Istream_cstrUC { char * s; }; Index: src/libcfa/iostream.c =================================================================== --- src/libcfa/iostream.c (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/libcfa/iostream.c (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Apr 28 13:08:25 2018 -// Update Count : 469 +// Last Modified On : Sat Jun 2 08:24:56 2018 +// Update Count : 471 // @@ -26,200 +26,223 @@ } -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, _Bool b ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%s", b ? "true" : "false" ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, char ch ) { - fmt( os, "%c", ch ); - if ( ch == '\n' ) setNL( os, true ); - sepOff( os ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, signed char c ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%hhd", c ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, unsigned char c ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%hhu", c ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, short int si ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%hd", si ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, unsigned short int usi ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%hu", usi ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, int i ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%d", i ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, unsigned int ui ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%u", ui ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, long int li ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%ld", li ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, unsigned long int uli ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%lu", uli ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, long long int lli ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%lld", lli ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, unsigned long long int ulli ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%llu", ulli ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, float f ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%g", f ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, double d ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%.*lg", DBL_DIG, d ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, long double ld ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%.*Lg", LDBL_DIG, ld ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, float _Complex fc ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%g%+gi", crealf( fc ), cimagf( fc ) ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, double _Complex dc ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%.*lg%+.*lgi", DBL_DIG, creal( dc ), DBL_DIG, cimag( dc ) ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, long double _Complex ldc ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%.*Lg%+.*Lgi", LDBL_DIG, creall( ldc ), LDBL_DIG, cimagl( ldc ) ); - return os; -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, const char * str ) { - enum { Open = 1, Close, OpenClose }; - static const unsigned char mask[256] @= { - // opening delimiters, no space after - ['('] : Open, ['['] : Open, ['{'] : Open, - ['='] : Open, ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open, - [(unsigned char)'¡'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open, - // closing delimiters, no space before - [','] : Close, ['.'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close, - ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close, - [')'] : Close, [']'] : Close, ['}'] : Close, - // opening-closing delimiters, no space before or after - ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose, [':'] : OpenClose, - [' '] : OpenClose, ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace - }; // mask - - if ( str[0] == '\0' ) { sepOff( os ); return os; } // null string => no separator - - // first character IS NOT spacing or closing punctuation => add left separator - unsigned char ch = str[0]; // must make unsigned - if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) { - fmt( os, "%s", sepGetCur( os ) ); - } // if - - // if string starts line, must reset to determine open state because separator is off - sepReset( os ); // reset separator - - // last character IS spacing or opening punctuation => turn off separator for next item - size_t len = strlen( str ); - ch = str[len - 1]; // must make unsigned - if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) { +forall( dtype ostype | ostream( ostype ) ) { + ostype & ?|?( ostype & os, _Bool b ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%s", b ? "true" : "false" ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, char ch ) { + fmt( os, "%c", ch ); + if ( ch == '\n' ) setNL( os, true ); + sepOff( os ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, signed char c ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%hhd", c ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, unsigned char c ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%hhu", c ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, short int si ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%hd", si ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, unsigned short int usi ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%hu", usi ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, int i ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%d", i ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, unsigned int ui ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%u", ui ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, long int li ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%ld", li ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, unsigned long int uli ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%lu", uli ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, long long int lli ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%lld", lli ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, unsigned long long int ulli ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%llu", ulli ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, float f ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%g", f ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, double d ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%.*lg", DBL_DIG, d ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, long double ld ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%.*Lg", LDBL_DIG, ld ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, float _Complex fc ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%g%+gi", crealf( fc ), cimagf( fc ) ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, double _Complex dc ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%.*lg%+.*lgi", DBL_DIG, creal( dc ), DBL_DIG, cimag( dc ) ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, long double _Complex ldc ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%.*Lg%+.*Lgi", LDBL_DIG, creall( ldc ), LDBL_DIG, cimagl( ldc ) ); + return os; + } // ?|? + + ostype & ?|?( ostype & os, const char * str ) { + enum { Open = 1, Close, OpenClose }; + static const unsigned char mask[256] @= { + // opening delimiters, no space after + ['('] : Open, ['['] : Open, ['{'] : Open, + ['='] : Open, ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open, + [(unsigned char)'¡'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open, + // closing delimiters, no space before + [','] : Close, ['.'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close, + ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close, + [')'] : Close, [']'] : Close, ['}'] : Close, + // opening-closing delimiters, no space before or after + ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose, [':'] : OpenClose, + [' '] : OpenClose, ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace + }; // mask + + if ( str[0] == '\0' ) { sepOff( os ); return os; } // null string => no separator + + // first character IS NOT spacing or closing punctuation => add left separator + unsigned char ch = str[0]; // must make unsigned + if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) { + fmt( os, "%s", sepGetCur( os ) ); + } // if + + // if string starts line, must reset to determine open state because separator is off + sepReset( os ); // reset separator + + // last character IS spacing or opening punctuation => turn off separator for next item + size_t len = strlen( str ); + ch = str[len - 1]; // must make unsigned + if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) { + sepOn( os ); + } else { + sepOff( os ); + } // if + if ( ch == '\n' ) setNL( os, true ); // check *AFTER* sepPrt call above as it resets NL flag + return write( os, str, len ); + } // ?|? + +// ostype & ?|?( ostype & os, const char16_t * str ) { +// if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); +// fmt( os, "%ls", str ); +// return os; +// } // ?|? + +// #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous +// ostype & ?|?( ostype & os, const char32_t * str ) { +// if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); +// fmt( os, "%ls", str ); +// return os; +// } // ?|? +// #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) + +// ostype & ?|?( ostype & os, const wchar_t * str ) { +// if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); +// fmt( os, "%ls", str ); +// return os; +// } // ?|? + + ostype & ?|?( ostype & os, const void * p ) { + if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); + fmt( os, "%p", p ); + return os; + } // ?|? + + + // manipulators + ostype & ?|?( ostype & os, ostype & (* manip)( ostype & ) ) { + return manip( os ); + } // ?|? + + ostype & sep( ostype & os ) { + os | sepGet( os ); + return os; + } // sep + + ostype & sepTuple( ostype & os ) { + os | sepGetTuple( os ); + return os; + } // sepTuple + + ostype & endl( ostype & os ) { + os | '\n'; + setNL( os, true ); + flush( os ); + sepOff( os ); // prepare for next line + return os; + } // endl + + ostype & sepOn( ostype & os ) { sepOn( os ); - } else { + return os; + } // sepOn + + ostype & sepOff( ostype & os ) { sepOff( os ); - } // if - if ( ch == '\n' ) setNL( os, true ); // check *AFTER* sepPrt call above as it resets NL flag - return write( os, str, len ); -} // ?|? - -// forall( dtype ostype | ostream( ostype ) ) -// ostype & ?|?( ostype & os, const char16_t * str ) { -// if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); -// fmt( os, "%ls", str ); -// return os; -// } // ?|? - -// #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous -// forall( dtype ostype | ostream( ostype ) ) -// ostype & ?|?( ostype & os, const char32_t * str ) { -// if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); -// fmt( os, "%ls", str ); -// return os; -// } // ?|? -// #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) - -// forall( dtype ostype | ostream( ostype ) ) -// ostype & ?|?( ostype & os, const wchar_t * str ) { -// if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); -// fmt( os, "%ls", str ); -// return os; -// } // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, const void * p ) { - if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); - fmt( os, "%p", p ); - return os; -} // ?|? + return os; + } // sepOff + + ostype & sepEnable( ostype & os ) { + sepEnable( os ); + return os; + } // sepEnable + + ostype & sepDisable( ostype & os ) { + sepDisable( os ); + return os; + } // sepDisable +} // distribution @@ -234,58 +257,7 @@ } // ?|? - -// manipulators -forall( dtype ostype | ostream( ostype ) ) -ostype & ?|?( ostype & os, ostype & (* manip)( ostype & ) ) { - return manip( os ); -} // ?|? - -forall( dtype ostype | ostream( ostype ) ) -ostype & sep( ostype & os ) { - os | sepGet( os ); - return os; -} // sep - -forall( dtype ostype | ostream( ostype ) ) -ostype & sepTuple( ostype & os ) { - os | sepGetTuple( os ); - return os; -} // sepTuple - -forall( dtype ostype | ostream( ostype ) ) -ostype & endl( ostype & os ) { - os | '\n'; - setNL( os, true ); - flush( os ); - sepOff( os ); // prepare for next line - return os; -} // endl - -forall( dtype ostype | ostream( ostype ) ) -ostype & sepOn( ostype & os ) { - sepOn( os ); - return os; -} // sepOn - -forall( dtype ostype | ostream( ostype ) ) -ostype & sepOff( ostype & os ) { - sepOff( os ); - return os; -} // sepOff - -forall( dtype ostype | ostream( ostype ) ) -ostype & sepEnable( ostype & os ) { - sepEnable( os ); - return os; -} // sepEnable - -forall( dtype ostype | ostream( ostype ) ) -ostype & sepDisable( ostype & os ) { - sepDisable( os ); - return os; -} // sepDisable - //--------------------------------------- +// writes the range [begin, end) to the given stream forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) ) void write( iterator_type begin, iterator_type end, ostype & os ) { @@ -302,137 +274,121 @@ //--------------------------------------- -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, _Bool & b ) { - char val[6]; - fmt( is, "%5s", val ); - if ( strcmp( val, "true" ) == 0 ) b = true; - else if ( strcmp( val, "false" ) == 0 ) b = false; - else { - fprintf( stderr, "invalid _Bool constant\n" ); - abort(); - } // if - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, char & c ) { - fmt( is, "%c", &c ); // must pass pointer through varg to fmt - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, signed char & sc ) { - fmt( is, "%hhd", &sc ); - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, unsigned char & usc ) { - fmt( is, "%hhu", &usc ); - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, short int & si ) { - fmt( is, "%hd", &si ); - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, unsigned short int & usi ) { - fmt( is, "%hu", &usi ); - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, int & i ) { - fmt( is, "%d", &i ); - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, unsigned int & ui ) { - fmt( is, "%u", &ui ); - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, long int & li ) { - fmt( is, "%ld", &li ); - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, unsigned long int & ulli ) { - fmt( is, "%lu", &ulli ); - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, long long int & lli ) { - fmt( is, "%lld", &lli ); - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, unsigned long long int & ulli ) { - fmt( is, "%llu", &ulli ); - return is; -} // ?|? - - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, float & f ) { - fmt( is, "%f", &f ); - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, double & d ) { - fmt( is, "%lf", &d ); - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, long double & ld ) { - fmt( is, "%Lf", &ld ); - return is; -} // ?|? - - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, float _Complex & fc ) { - float re, im; - fmt( is, "%g%gi", &re, &im ); - fc = re + im * _Complex_I; - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, double _Complex & dc ) { - double re, im; - fmt( is, "%lf%lfi", &re, &im ); - dc = re + im * _Complex_I; - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, long double _Complex & ldc ) { - long double re, im; - fmt( is, "%Lf%Lfi", &re, &im ); - ldc = re + im * _Complex_I; - return is; -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & ?|?( istype & is, istype & (* manip)( istype & ) ) { - return manip( is ); -} // ?|? - -forall( dtype istype | istream( istype ) ) -istype & endl( istype & is ) { - fmt( is, "%*[ \t\f\n\r\v]" ); // ignore whitespace - return is; -} // endl +forall( dtype istype | istream( istype ) ) { + istype & ?|?( istype & is, _Bool & b ) { + char val[6]; + fmt( is, "%5s", val ); + if ( strcmp( val, "true" ) == 0 ) b = true; + else if ( strcmp( val, "false" ) == 0 ) b = false; + else { + fprintf( stderr, "invalid _Bool constant\n" ); + abort(); + } // if + return is; + } // ?|? + + istype & ?|?( istype & is, char & c ) { + fmt( is, "%c", &c ); // must pass pointer through varg to fmt + return is; + } // ?|? + + istype & ?|?( istype & is, signed char & sc ) { + fmt( is, "%hhd", &sc ); + return is; + } // ?|? + + istype & ?|?( istype & is, unsigned char & usc ) { + fmt( is, "%hhu", &usc ); + return is; + } // ?|? + + istype & ?|?( istype & is, short int & si ) { + fmt( is, "%hd", &si ); + return is; + } // ?|? + + istype & ?|?( istype & is, unsigned short int & usi ) { + fmt( is, "%hu", &usi ); + return is; + } // ?|? + + istype & ?|?( istype & is, int & i ) { + fmt( is, "%d", &i ); + return is; + } // ?|? + + istype & ?|?( istype & is, unsigned int & ui ) { + fmt( is, "%u", &ui ); + return is; + } // ?|? + + istype & ?|?( istype & is, long int & li ) { + fmt( is, "%ld", &li ); + return is; + } // ?|? + + istype & ?|?( istype & is, unsigned long int & ulli ) { + fmt( is, "%lu", &ulli ); + return is; + } // ?|? + + istype & ?|?( istype & is, long long int & lli ) { + fmt( is, "%lld", &lli ); + return is; + } // ?|? + + istype & ?|?( istype & is, unsigned long long int & ulli ) { + fmt( is, "%llu", &ulli ); + return is; + } // ?|? + + + istype & ?|?( istype & is, float & f ) { + fmt( is, "%f", &f ); + return is; + } // ?|? + + istype & ?|?( istype & is, double & d ) { + fmt( is, "%lf", &d ); + return is; + } // ?|? + + istype & ?|?( istype & is, long double & ld ) { + fmt( is, "%Lf", &ld ); + return is; + } // ?|? + + + istype & ?|?( istype & is, float _Complex & fc ) { + float re, im; + fmt( is, "%g%gi", &re, &im ); + fc = re + im * _Complex_I; + return is; + } // ?|? + + istype & ?|?( istype & is, double _Complex & dc ) { + double re, im; + fmt( is, "%lf%lfi", &re, &im ); + dc = re + im * _Complex_I; + return is; + } // ?|? + + istype & ?|?( istype & is, long double _Complex & ldc ) { + long double re, im; + fmt( is, "%Lf%Lfi", &re, &im ); + ldc = re + im * _Complex_I; + return is; + } // ?|? + + + // manipulators + istype & ?|?( istype & is, istype & (* manip)( istype & ) ) { + return manip( is ); + } // ?|? + + istype & endl( istype & is ) { + fmt( is, "%*[ \t\f\n\r\v]" ); // ignore whitespace + return is; + } // endl +} // distribution _Istream_cstrUC cstr( char * str ) { return (_Istream_cstrUC){ str }; } Index: src/libcfa/rational =================================================================== --- src/libcfa/rational (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/libcfa/rational (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -12,6 +12,6 @@ // Created On : Wed Apr 6 17:56:25 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Dec 6 23:12:53 2017 -// Update Count : 97 +// Last Modified On : Sat Jun 2 09:10:01 2018 +// Update Count : 105 // @@ -46,84 +46,53 @@ // implementation -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -struct Rational { - RationalImpl numerator, denominator; // invariant: denominator > 0 -}; // Rational +forall( otype RationalImpl | arithmetic( RationalImpl ) ) { + struct Rational { + RationalImpl numerator, denominator; // invariant: denominator > 0 + }; // Rational -// constructors + // constructors -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) & r ); + void ?{}( Rational(RationalImpl) & r ); + void ?{}( Rational(RationalImpl) & r, RationalImpl n ); + void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ); + void ?{}( Rational(RationalImpl) & r, zero_t ); + void ?{}( Rational(RationalImpl) & r, one_t ); -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) & r, RationalImpl n ); + // numerator/denominator getter -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ); + RationalImpl numerator( Rational(RationalImpl) r ); + RationalImpl denominator( Rational(RationalImpl) r ); + [ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ); -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) & r, zero_t ); + // numerator/denominator setter -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) & r, one_t ); + RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n ); + RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d ); -// numerator/denominator getter + // comparison -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -RationalImpl numerator( Rational(RationalImpl) r ); + int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r ); + int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r ); + int ??( Rational(RationalImpl) l, Rational(RationalImpl) r ); + int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r ); -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -RationalImpl denominator( Rational(RationalImpl) r ); + // arithmetic -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -[ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ); + Rational(RationalImpl) +?( Rational(RationalImpl) r ); + Rational(RationalImpl) -?( Rational(RationalImpl) r ); + Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r ); + Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r ); + Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ); + Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r ); -// numerator/denominator setter + // I/O + forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } ) + istype & ?|?( istype &, Rational(RationalImpl) & ); -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n ); - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d ); - -// comparison - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r ); - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r ); - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -int ??( Rational(RationalImpl) l, Rational(RationalImpl) r ); - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r ); - -// arithmetic - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) +?( Rational(RationalImpl) r ); - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) -?( Rational(RationalImpl) r ); - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r ); - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r ); - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ); - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r ); + forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) + ostype & ?|?( ostype &, Rational(RationalImpl ) ); +} // distribution // conversion @@ -133,13 +102,4 @@ Rational(RationalImpl) narrow( double f, RationalImpl md ); -// I/O -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } ) -istype & ?|?( istype &, Rational(RationalImpl) & ); - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) -ostype & ?|?( ostype &, Rational(RationalImpl ) ); - // Local Variables: // // mode: c // Index: src/libcfa/rational.c =================================================================== --- src/libcfa/rational.c (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/libcfa/rational.c (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -10,6 +10,6 @@ // Created On : Wed Apr 6 17:54:28 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Dec 6 23:13:58 2017 -// Update Count : 156 +// Last Modified On : Sat Jun 2 09:24:33 2018 +// Update Count : 162 // @@ -18,173 +18,166 @@ #include "stdlib" -// helper routines - -// Calculate greatest common denominator of two numbers, the first of which may be negative. Used to reduce rationals. -// alternative: https://en.wikipedia.org/wiki/Binary_GCD_algorithm -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -static RationalImpl gcd( RationalImpl a, RationalImpl b ) { - for ( ;; ) { // Euclid's algorithm - RationalImpl r = a % b; - if ( r == (RationalImpl){0} ) break; - a = b; - b = r; - } // for - return b; -} // gcd - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -static RationalImpl simplify( RationalImpl & n, RationalImpl & d ) { - if ( d == (RationalImpl){0} ) { - serr | "Invalid rational number construction: denominator cannot be equal to 0." | endl; - exit( EXIT_FAILURE ); - } // exit - if ( d < (RationalImpl){0} ) { d = -d; n = -n; } // move sign to numerator - return gcd( abs( n ), d ); // simplify -} // Rationalnumber::simplify - - -// constructors - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) & r ) { - r{ (RationalImpl){0}, (RationalImpl){1} }; -} // rational - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) & r, RationalImpl n ) { - r{ n, (RationalImpl){1} }; -} // rational - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) { - RationalImpl t = simplify( n, d ); // simplify - r.numerator = n / t; - r.denominator = d / t; -} // rational - - -// getter for numerator/denominator - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -RationalImpl numerator( Rational(RationalImpl) r ) { - return r.numerator; -} // numerator - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -RationalImpl denominator( Rational(RationalImpl) r ) { - return r.denominator; -} // denominator - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -[ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ) { - return dest = src.[ numerator, denominator ]; -} - -// setter for numerator/denominator - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n ) { - RationalImpl prev = r.numerator; - RationalImpl t = gcd( abs( n ), r.denominator ); // simplify - r.numerator = n / t; - r.denominator = r.denominator / t; - return prev; -} // numerator - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d ) { - RationalImpl prev = r.denominator; - RationalImpl t = simplify( r.numerator, d ); // simplify - r.numerator = r.numerator / t; - r.denominator = d / t; - return prev; -} // denominator - - -// comparison - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { - return l.numerator * r.denominator == l.denominator * r.numerator; -} // ?==? - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { - return ! ( l == r ); -} // ?!=? - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -int ??( Rational(RationalImpl) l, Rational(RationalImpl) r ) { - return ! ( l <= r ); -} // ?>? - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { - return ! ( l < r ); -} // ?>=? - - -// arithmetic - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) +?( Rational(RationalImpl) r ) { - Rational(RationalImpl) t = { r.numerator, r.denominator }; - return t; -} // +? - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) -?( Rational(RationalImpl) r ) { - Rational(RationalImpl) t = { -r.numerator, r.denominator }; - return t; -} // -? - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { - if ( l.denominator == r.denominator ) { // special case - Rational(RationalImpl) t = { l.numerator + r.numerator, l.denominator }; - return t; - } else { - Rational(RationalImpl) t = { l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator }; - return t; - } // if -} // ?+? - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { - if ( l.denominator == r.denominator ) { // special case - Rational(RationalImpl) t = { l.numerator - r.numerator, l.denominator }; - return t; - } else { - Rational(RationalImpl) t = { l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator }; - return t; - } // if -} // ?-? - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { - Rational(RationalImpl) t = { l.numerator * r.numerator, l.denominator * r.denominator }; - return t; -} // ?*? - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { - if ( r.numerator < (RationalImpl){0} ) { - r.numerator = -r.numerator; - r.denominator = -r.denominator; - } // if - Rational(RationalImpl) t = { l.numerator * r.denominator, l.denominator * r.numerator }; - return t; -} // ?/? - +forall( otype RationalImpl | arithmetic( RationalImpl ) ) { + // helper routines + + // Calculate greatest common denominator of two numbers, the first of which may be negative. Used to reduce + // rationals. alternative: https://en.wikipedia.org/wiki/Binary_GCD_algorithm + static RationalImpl gcd( RationalImpl a, RationalImpl b ) { + for ( ;; ) { // Euclid's algorithm + RationalImpl r = a % b; + if ( r == (RationalImpl){0} ) break; + a = b; + b = r; + } // for + return b; + } // gcd + + static RationalImpl simplify( RationalImpl & n, RationalImpl & d ) { + if ( d == (RationalImpl){0} ) { + serr | "Invalid rational number construction: denominator cannot be equal to 0." | endl; + exit( EXIT_FAILURE ); + } // exit + if ( d < (RationalImpl){0} ) { d = -d; n = -n; } // move sign to numerator + return gcd( abs( n ), d ); // simplify + } // Rationalnumber::simplify + + // constructors + + void ?{}( Rational(RationalImpl) & r ) { + r{ (RationalImpl){0}, (RationalImpl){1} }; + } // rational + + void ?{}( Rational(RationalImpl) & r, RationalImpl n ) { + r{ n, (RationalImpl){1} }; + } // rational + + void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) { + RationalImpl t = simplify( n, d ); // simplify + r.numerator = n / t; + r.denominator = d / t; + } // rational + + + // getter for numerator/denominator + + RationalImpl numerator( Rational(RationalImpl) r ) { + return r.numerator; + } // numerator + + RationalImpl denominator( Rational(RationalImpl) r ) { + return r.denominator; + } // denominator + + [ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ) { + return dest = src.[ numerator, denominator ]; + } // ?=? + + // setter for numerator/denominator + + RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n ) { + RationalImpl prev = r.numerator; + RationalImpl t = gcd( abs( n ), r.denominator ); // simplify + r.numerator = n / t; + r.denominator = r.denominator / t; + return prev; + } // numerator + + RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d ) { + RationalImpl prev = r.denominator; + RationalImpl t = simplify( r.numerator, d ); // simplify + r.numerator = r.numerator / t; + r.denominator = d / t; + return prev; + } // denominator + + // comparison + + int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { + return l.numerator * r.denominator == l.denominator * r.numerator; + } // ?==? + + int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { + return ! ( l == r ); + } // ?!=? + + int ??( Rational(RationalImpl) l, Rational(RationalImpl) r ) { + return ! ( l <= r ); + } // ?>? + + int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { + return ! ( l < r ); + } // ?>=? + + // arithmetic + + Rational(RationalImpl) +?( Rational(RationalImpl) r ) { + Rational(RationalImpl) t = { r.numerator, r.denominator }; + return t; + } // +? + + Rational(RationalImpl) -?( Rational(RationalImpl) r ) { + Rational(RationalImpl) t = { -r.numerator, r.denominator }; + return t; + } // -? + + Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { + if ( l.denominator == r.denominator ) { // special case + Rational(RationalImpl) t = { l.numerator + r.numerator, l.denominator }; + return t; + } else { + Rational(RationalImpl) t = { l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator }; + return t; + } // if + } // ?+? + + Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { + if ( l.denominator == r.denominator ) { // special case + Rational(RationalImpl) t = { l.numerator - r.numerator, l.denominator }; + return t; + } else { + Rational(RationalImpl) t = { l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator }; + return t; + } // if + } // ?-? + + Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { + Rational(RationalImpl) t = { l.numerator * r.numerator, l.denominator * r.denominator }; + return t; + } // ?*? + + Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { + if ( r.numerator < (RationalImpl){0} ) { + r.numerator = -r.numerator; + r.denominator = -r.denominator; + } // if + Rational(RationalImpl) t = { l.numerator * r.denominator, l.denominator * r.numerator }; + return t; + } // ?/? + + // I/O + + forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } ) + istype & ?|?( istype & is, Rational(RationalImpl) & r ) { + RationalImpl t; + is | r.numerator | r.denominator; + t = simplify( r.numerator, r.denominator ); + r.numerator /= t; + r.denominator /= t; + return is; + } // ?|? + + forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) + ostype & ?|?( ostype & os, Rational(RationalImpl ) r ) { + return os | r.numerator | '/' | r.denominator; + } // ?|? +} // distribution // conversion @@ -195,7 +188,7 @@ } // widen -// http://www.ics.uci.edu/~eppstein/numth/frap.c forall( otype RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); RationalImpl convert( double ); } ) Rational(RationalImpl) narrow( double f, RationalImpl md ) { + // http://www.ics.uci.edu/~eppstein/numth/frap.c if ( md <= (RationalImpl){1} ) { // maximum fractional digits too small? return (Rational(RationalImpl)){ convert( f ), (RationalImpl){1}}; // truncate fraction @@ -224,24 +217,4 @@ } // narrow - -// I/O - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } ) -istype & ?|?( istype & is, Rational(RationalImpl) & r ) { - RationalImpl t; - is | r.numerator | r.denominator; - t = simplify( r.numerator, r.denominator ); - r.numerator /= t; - r.denominator /= t; - return is; -} // ?|? - -forall( otype RationalImpl | arithmetic( RationalImpl ) ) -forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) -ostype & ?|?( ostype & os, Rational(RationalImpl ) r ) { - return os | r.numerator | '/' | r.denominator; -} // ?|? - // Local Variables: // // tab-width: 4 // Index: src/libcfa/stdlib =================================================================== --- src/libcfa/stdlib (revision 863c413f24815aa1a75d3e6adbf647b31c863f8a) +++ src/libcfa/stdlib (revision 249d6e622aa9420065e79f351b95b2bfd0d4cacc) @@ -10,11 +10,16 @@ // Created On : Thu Jan 28 17:12:35 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed May 16 07:53:10 2018 -// Update Count : 300 +// Last Modified On : Sat Jun 2 08:46:35 2018 +// Update Count : 306 // #pragma once -#include // strto*, *abs +#include // allocation, strto*, *abs +extern "C" { + void * memalign( size_t align, size_t size ); + void * aligned_alloc( size_t align, size_t size ); + void * memset( void * dest, int c, size_t size ); +} // extern "C" //--------------------------------------- @@ -27,6 +32,7 @@ //--------------------------------------- -// C dynamic allocation static inline forall( dtype T | sized(T) ) { + // C dynamic allocation + T * malloc( void ) { // printf( "* malloc\n" ); @@ -51,5 +57,4 @@ } // realloc - extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void * T * memalign( size_t align ) { //printf( "X4\n" ); @@ -57,5 +62,4 @@ } // memalign - extern "C" { void * aligned_alloc( size_t align, size_t size ); } // use default C routine for void * T * aligned_alloc( size_t align ) { //printf( "X5\n" ); @@ -70,5 +74,4 @@ // Cforall dynamic allocation - extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void * T * alloc( void ) { @@ -103,45 +106,59 @@ forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ); -static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) { - //printf( "X13\n" ); - return (T *)memalign( align, sizeof(T) ); -} // align_alloc -static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) { - //printf( "X14\n" ); - T * ptr = (T *)memalign( align, sizeof(T) ); - return (T *)memset( ptr, (int)fill, sizeof(T) ); -} // align_alloc - -static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) { - //printf( "X15\n" ); - return (T *)memalign( align, dim * sizeof(T) ); -} // align_alloc -static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) { - //printf( "X16\n" ); - T * ptr = (T *)memalign( align, dim * sizeof(T) ); - return (T *)memset( ptr, (int)fill, dim * sizeof(T) ); -} // align_alloc - - -// data, non-array types -static inline forall( dtype T | sized(T) ) T * memset( T * dest, char c ) { - //printf( "X17\n" ); - return (T *)memset( dest, c, sizeof(T) ); -} // memset -extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src ) { - //printf( "X18\n" ); - return (T *)memcpy( dest, src, sizeof(T) ); -} // memcpy - -// data, array types -static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) { - //printf( "X19\n" ); - return (T *)(void *)memset( dest, c, dim * sizeof(T) ); // C memset -} // memset -static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) { - //printf( "X20\n" ); - return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy -} // memcpy + +static inline forall( dtype T | sized(T) ) { + T * align_alloc( size_t align ) { + //printf( "X13\n" ); + return (T *)memalign( align, sizeof(T) ); + } // align_alloc + + T * align_alloc( size_t align, char fill ) { + //printf( "X14\n" ); + T * ptr = (T *)memalign( align, sizeof(T) ); + return (T *)memset( ptr, (int)fill, sizeof(T) ); + } // align_alloc + + T * align_alloc( size_t align, size_t dim ) { + //printf( "X15\n" ); + return (T *)memalign( align, dim * sizeof(T) ); + } // align_alloc + + T * align_alloc( size_t align, size_t dim, char fill ) { + //printf( "X16\n" ); + T * ptr = (T *)memalign( align, dim * sizeof(T) ); + return (T *)memset( ptr, (int)fill, dim * sizeof(T) ); + } // align_alloc +} // distribution + + +static inline forall( dtype T | sized(T) ) { + // data, non-array types + + T * memset( T * dest, char c ) { + //printf( "X17\n" ); + return (T *)memset( dest, c, sizeof(T) ); + } // memset + + extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void * + + T * memcpy( T * dest, const T * src ) { + //printf( "X18\n" ); + return (T *)memcpy( dest, src, sizeof(T) ); + } // memcpy +} // distribution + +static inline forall( dtype T | sized(T) ) { + // data, array types + + T * memset( T dest[], size_t dim, char c ) { + //printf( "X19\n" ); + return (T *)(void *)memset( dest, c, dim * sizeof(T) ); // C memset + } // memset + + T * memcpy( T dest[], const T src[], size_t dim ) { + //printf( "X20\n" ); + return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy + } // memcpy +} // distribution // allocation/deallocation and constructor/destructor, non-array types @@ -189,45 +206,23 @@ //--------------------------------------- -forall( otype E | { int ?= 4 incorrect" | endl; + } // if } // main