Changes in / [6ed1d4b:6ce67ce]
- Location:
- src
- Files:
-
- 2 added
- 24 edited
Legend:
- Unmodified
- Added
- Removed
-
src/GenPoly/Box.cc
r6ed1d4b r6ce67ce 73 73 /// Makes a new temporary array holding the offsets of the fields of `type`, and returns a new variable expression referencing it 74 74 Expression *makeOffsetArray( StructInstType *type ); 75 /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application 76 void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ); 75 77 /// passes extra type parameters into a polymorphic function application 76 void passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );78 void passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ); 77 79 /// wraps a function application with a new temporary for the out-parameter return value 78 80 Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ); … … 398 400 } 399 401 400 void Pass1::passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) { 402 void Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) { 403 Type *polyBase = hasPolyBase( parmType, exprTyVars ); 404 if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) { 405 std::string sizeName = sizeofName( polyBase ); 406 if ( seenTypes.count( sizeName ) ) return; 407 408 arg = appExpr->get_args().insert( arg, new SizeofExpr( argBaseType->clone() ) ); 409 arg++; 410 arg = appExpr->get_args().insert( arg, new AlignofExpr( argBaseType->clone() ) ); 411 arg++; 412 if ( dynamic_cast< StructInstType* >( polyBase ) ) { 413 if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) { 414 arg = appExpr->get_args().insert( arg, makeOffsetArray( argBaseStructType ) ); 415 arg++; 416 } else { 417 throw SemanticError( "Cannot pass non-struct type for generic struct" ); 418 } 419 } 420 421 seenTypes.insert( sizeName ); 422 } 423 } 424 425 void Pass1::passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) { 401 426 // pass size/align for type variables 402 427 for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) { … … 424 449 std::list< Expression* >::const_iterator fnArg = arg; 425 450 std::set< std::string > seenTypes; //< names for generic types we've seen 451 452 // a polymorphic return type may need to be added to the argument list 453 if ( polyRetType ) { 454 Type *concRetType = replaceWithConcrete( appExpr, polyRetType ); 455 passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes ); 456 } 457 458 // add type information args for presently unseen types in parameter list 426 459 for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) { 427 Type *polyBase = hasPolyBase( (*fnParm)->get_type(), exprTyVars ); 428 if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) { 429 std::string sizeName = sizeofName( polyBase ); 430 if ( seenTypes.count( sizeName ) ) continue; 431 432 VariableExpr *fnArgBase = getBaseVar( *fnArg ); 433 assert( fnArgBase && ! fnArgBase->get_results().empty() ); 434 Type *argBaseType = fnArgBase->get_results().front(); 435 arg = appExpr->get_args().insert( arg, new SizeofExpr( argBaseType->clone() ) ); 436 arg++; 437 arg = appExpr->get_args().insert( arg, new AlignofExpr( argBaseType->clone() ) ); 438 arg++; 439 if ( dynamic_cast< StructInstType* >( polyBase ) ) { 440 if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) { 441 arg = appExpr->get_args().insert( arg, makeOffsetArray( argBaseStructType ) ); 442 arg++; 443 } else { 444 throw SemanticError( "Cannot pass non-struct type for generic struct" ); 445 } 446 } 447 448 seenTypes.insert( sizeName ); 449 } 460 VariableExpr *fnArgBase = getBaseVar( *fnArg ); 461 if ( ! fnArgBase || fnArgBase->get_results().empty() ) continue; 462 passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_results().front(), arg, exprTyVars, seenTypes ); 450 463 } 451 464 } … … 470 483 ObjectDecl *newObj = makeTemporary( retType->clone() ); 471 484 Expression *paramExpr = new VariableExpr( newObj ); 472 // If the type of the temporary is not polymorphic, box temporary by taking its address; otherwise the 473 // temporary is already boxed and can be used directly. 485 486 // If the type of the temporary is not polymorphic, box temporary by taking its address; 487 // otherwise the temporary is already boxed and can be used directly. 474 488 if ( ! isPolyType( newObj->get_type(), scopeTyVars, env ) ) { 475 489 paramExpr = new AddressExpr( paramExpr ); … … 520 534 assert( env ); 521 535 Type *concrete = replaceWithConcrete( appExpr, polyType ); 536 // add out-parameter for return value 522 537 return addRetParam( appExpr, function, concrete, arg ); 523 538 } … … 542 557 assert( ! arg->get_results().empty() ); 543 558 if ( isPolyType( param, exprTyVars ) ) { 544 if ( dynamic_cast< TypeInstType *>( arg->get_results().front() ) ) {545 // if the argument's type is a type parameter, we don't need to box again!559 if ( isPolyType( arg->get_results().front() ) ) { 560 // if the argument's type is polymorphic, we don't need to box again! 546 561 return; 547 562 } else if ( arg->get_results().front()->get_isLvalue() ) { … … 622 637 assert( arg ); 623 638 if ( isPolyType( realParam->get_type(), tyVars ) ) { 624 if ( dynamic_cast<TypeInstType *>(arg->get_type()) == NULL) {639 if ( ! isPolyType( arg->get_type() ) ) { 625 640 UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) ); 626 641 deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) ); … … 917 932 std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin(); 918 933 919 if ( ReferenceToType *polyType = isPolyRet( function ) ) { 920 ret = addPolyRetParam( appExpr, function, polyType, arg ); 934 TyVarMap exprTyVars; 935 makeTyVarMap( function, exprTyVars ); 936 ReferenceToType *polyRetType = 0; 937 938 if ( polyRetType = isPolyRet( function ) ) { 939 ret = addPolyRetParam( appExpr, function, polyRetType, arg ); 921 940 } else if ( needsAdapter( function, scopeTyVars ) ) { 922 941 // std::cerr << "needs adapter: "; … … 930 949 arg = appExpr->get_args().begin(); 931 950 932 TyVarMap exprTyVars; 933 makeTyVarMap( function, exprTyVars ); 934 935 passTypeVars( appExpr, arg, exprTyVars ); 951 passTypeVars( appExpr, polyRetType, arg, exprTyVars ); 936 952 addInferredParams( appExpr, function, arg, exprTyVars ); 937 953 … … 992 1008 } 993 1009 1010 /// Wraps a function declaration in a new pointer-to-function variable expression 1011 VariableExpr *wrapFunctionDecl( DeclarationWithType *functionDecl ) { 1012 // line below cloned from FixFunction.cc 1013 ObjectDecl *functionObj = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0, 1014 new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 ); 1015 functionObj->set_mangleName( functionDecl->get_mangleName() ); 1016 return new VariableExpr( functionObj ); 1017 } 1018 994 1019 Statement * Pass1::mutate( ReturnStmt *returnStmt ) { 995 1020 if ( retval && returnStmt->get_expr() ) { … … 1007 1032 1008 1033 // find assignment operator for (polymorphic) return type 1009 DeclarationWithType *assignDecl= 0;1034 ApplicationExpr *assignExpr = 0; 1010 1035 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() ) ) { 1036 // find assignment operator for type variable 1011 1037 std::map< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() ); 1012 1038 if ( assignIter == assignOps.end() ) { 1013 1039 throw SemanticError( "Attempt to return dtype or ftype object in ", returnStmt->get_expr() ); 1014 1040 } // if 1015 assign Decl = assignIter->second;1041 assignExpr = new ApplicationExpr( new VariableExpr( assignIter->second ) ); 1016 1042 } else if ( ReferenceToType *refType = dynamic_cast< ReferenceToType *>( retval->get_type() ) ) { 1043 // find assignment operator for generic type 1017 1044 ScopedMap< std::string, DeclarationWithType *>::const_iterator assignIter = scopedAssignOps.find( refType->get_name() ); 1018 1045 if ( assignIter == scopedAssignOps.end() ) { 1019 1046 throw SemanticError( "Attempt to return dtype or ftype generic object in ", returnStmt->get_expr() ); 1020 1047 } 1048 1049 // wrap it up in an application expression 1021 1050 DeclarationWithType *functionDecl = assignIter->second; 1022 // line below cloned from FixFunction.cc 1023 assignDecl = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0, 1024 new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 ); 1025 assignDecl->set_mangleName( functionDecl->get_mangleName() ); 1051 assignExpr = new ApplicationExpr( wrapFunctionDecl( functionDecl ) ); 1052 assignExpr->set_env( env->clone() ); 1053 1054 // find each of its needed secondary assignment operators 1055 std::list< Expression* > &tyParams = refType->get_parameters(); 1056 std::list< TypeDecl* > &forallParams = functionDecl->get_type()->get_forall(); 1057 std::list< Expression* >::const_iterator tyIt = tyParams.begin(); 1058 std::list< TypeDecl* >::const_iterator forallIt = forallParams.begin(); 1059 for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) { 1060 if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue; // skip types with no assign op (ftype/dtype) 1061 1062 std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions(); 1063 assert( ! asserts.empty() && "Type param needs assignment operator assertion" ); 1064 DeclarationWithType *actualDecl = asserts.front(); 1065 ReferenceToType *actualType = isAssignment( actualDecl ); 1066 assert( actualType && "First assertion of type with assertions should be assignment operator" ); 1067 TypeExpr *formalTypeExpr = dynamic_cast< TypeExpr* >( *tyIt ); 1068 assert( formalTypeExpr && "type parameters must be type expressions" ); 1069 Type *formalType = formalTypeExpr->get_type(); 1070 assignExpr->get_env()->add( actualType->get_name(), formalType ); 1071 1072 DeclarationWithType *assertAssign = 0; 1073 if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) { 1074 std::map< std::string, DeclarationWithType *>::const_iterator assertAssignIt = assignOps.find( formalTypeInstType->get_name() ); 1075 if ( assertAssignIt == assignOps.end() ) { 1076 throw SemanticError( "No assignment operation found for ", formalTypeInstType ); 1077 } 1078 assertAssign = assertAssignIt->second; 1079 //assignExpr->get_env()->add( formalTypeInstType->get_name(), actualType ); 1080 } else if ( ReferenceToType *formalReferenceType = dynamic_cast< ReferenceToType* >( formalType ) ) { 1081 ScopedMap< std::string, DeclarationWithType *>::const_iterator assertAssignIt = scopedAssignOps.find( formalReferenceType->get_name() ); 1082 if ( assertAssignIt == scopedAssignOps.end() ) { 1083 throw SemanticError( "No assignment operation found for ", formalReferenceType ); 1084 } 1085 assertAssign = assertAssignIt->second; 1086 } else assert( false && "returning polymorphic types with non struct/polymorphic parameters not yet supported" ); 1087 1088 1089 assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ] 1090 = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) ); 1091 } 1026 1092 } 1027 assert( assign Decl);1093 assert( assignExpr ); 1028 1094 1029 1095 // replace return statement with appropriate assignment to out parameter 1030 ApplicationExpr *assignExpr = new ApplicationExpr( new VariableExpr( assignDecl ) );1031 1096 Expression *retParm = new NameExpr( retval->get_name() ); 1032 1097 retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) ); … … 1180 1245 } 1181 1246 1182 // add size/align for generic types to parameter list1247 // add size/align for generic parameter types to parameter list 1183 1248 std::set< std::string > seenTypes; // sizeofName for generic types we've seen 1184 1249 for ( std::list< DeclarationWithType* >::const_iterator fnParm = last; fnParm != funcType->get_parameters().end(); ++fnParm ) { … … 1295 1360 1296 1361 if ( DeclarationWithType *declWithType = dynamic_cast< DeclarationWithType* >( *decl ) ) { 1297 if ( memberDecl->get_mangleName() == declWithType->get_mangleName() ) return i; 1362 if ( memberDecl->get_mangleName().empty() || declWithType->get_mangleName().empty() 1363 || memberDecl->get_mangleName() == declWithType->get_mangleName() ) return i; 1298 1364 else continue; 1299 1365 } else return i; … … 1341 1407 if ( ! objectType ) return memberExpr; 1342 1408 1409 Expression *newMemberExpr = 0; 1343 1410 if ( StructInstType *structType = dynamic_cast< StructInstType* >( objectType ) ) { 1344 1411 // look up offset index … … 1350 1417 fieldLoc->get_args().push_back( makeDerefdVar( varExpr->clone(), varDepth ) ); 1351 1418 fieldLoc->get_args().push_back( makeOffsetIndex( objectType, i ) ); 1352 1353 delete memberExpr; 1354 return fieldLoc; 1355 } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType ) ) { 1419 newMemberExpr = fieldLoc; 1420 } else if ( dynamic_cast< UnionInstType* >( objectType ) ) { 1356 1421 // union members are all at offset zero, so build appropriately-dereferenced variable 1357 Expression *derefdVar = makeDerefdVar( varExpr->clone(), varDepth ); 1358 delete memberExpr; 1359 return derefdVar; 1422 newMemberExpr = makeDerefdVar( varExpr->clone(), varDepth ); 1360 1423 } else return memberExpr; 1424 assert( newMemberExpr ); 1425 1426 // wrap pointer members in appropriate cast 1427 if ( dynamic_cast< PointerType* >( memberExpr->get_member()->get_type() ) ) { 1428 CastExpr *ptrCastExpr = new CastExpr( newMemberExpr, new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ) ) ); 1429 UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) ); 1430 derefExpr->get_args().push_back( ptrCastExpr ); 1431 newMemberExpr = derefExpr; 1432 } 1433 1434 delete memberExpr; 1435 return newMemberExpr; 1361 1436 } 1362 1437 … … 1379 1454 delete offsetofExpr; 1380 1455 return offsetInd; 1381 } else if ( UnionInstType *unionType =dynamic_cast< UnionInstType* >( ty ) ) {1456 } else if ( dynamic_cast< UnionInstType* >( ty ) ) { 1382 1457 // all union members are at offset zero 1383 1458 delete offsetofExpr; -
src/ResolvExpr/CastCost.cc
r6ed1d4b r6ce67ce 9 9 // Author : Richard C. Bilson 10 10 // Created On : Sun May 17 06:57:43 2015 11 // Last Modified By : Rob Schluntz12 // Last Modified On : Mon Oct 05 14:48:45 201513 // Update Count : 511 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Feb 2 15:34:36 2016 13 // Update Count : 7 14 14 // 15 15 … … 69 69 PointerType *destAsPointer = dynamic_cast< PointerType* >( dest ); 70 70 if ( destAsPointer && basicType->isInteger() ) { 71 cost = Cost( 1, 0, 0 ); 71 //cost = Cost( 1, 0, 0 ); 72 cost = Cost::infinity; 72 73 } else { 73 74 ConversionCost::visit( basicType ); … … 87 88 cost = Cost( 0, 0, 1 ); 88 89 } else if ( castResult < 0 ) { 89 cost = Cost( 1, 0, 0 ); 90 cost = Cost::infinity; 91 //cost = Cost( 1, 0, 0 ); 90 92 } // if 91 93 } // if 92 94 } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) { 93 95 if ( destAsBasic->isInteger() ) { 94 cost = Cost( 1, 0, 0 ); 96 //cost = Cost( 1, 0, 0 ); 97 cost = Cost::infinity; 95 98 } // if 96 99 } -
src/ResolvExpr/Resolver.cc
r6ed1d4b r6ce67ce 10 10 // Created On : Sun May 17 12:17:01 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Jul 24 17:33:54 201513 // Update Count : 17 812 // Last Modified On : Tue Feb 9 21:57:52 2016 13 // Update Count : 179 14 14 // 15 15 … … 322 322 BasicType::SignedInt); 323 323 } else { 324 DeclarationWithType * decl = lookupId( n);324 DeclarationWithType * decl = lookupId( n ); 325 325 initContext = decl->get_type(); 326 326 } … … 344 344 if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_results().front() ) ) { 345 345 if ( isCharType( pt->get_base() ) ) { 346 // strip cast if we're initializing a char[] with a char *, e.g. 347 // char x[] = "hello"; 346 // strip cast if we're initializing a char[] with a char *, e.g. char x[] = "hello"; 348 347 CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ); 349 348 singleInit->set_value( ce->get_arg() ); -
src/SymTab/Validate.cc
r6ed1d4b r6ce67ce 382 382 // it's not a semantic error if the struct is not found, just an implicit forward declaration 383 383 if ( st ) { 384 assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );384 //assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() ); 385 385 structInst->set_baseStruct( st ); 386 386 } // if … … 659 659 } 660 660 661 /// Creates a new type decl that's the same as src, but renamed and with only the ?=? assertion (for complete types only) 662 TypeDecl *cloneAndRename( TypeDecl *src, const std::string &name ) { 663 TypeDecl *dst = new TypeDecl( name, src->get_storageClass(), 0, src->get_kind() ); 664 665 if ( src->get_kind() == TypeDecl::Any ) { 666 // just include assignment operator assertion 667 TypeInstType *assignParamType = new TypeInstType( Type::Qualifiers(), name, dst ); 668 FunctionType *assignFunctionType = new FunctionType( Type::Qualifiers(), false ); 669 assignFunctionType->get_returnVals().push_back( 670 new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType->clone(), 0 ) ); 671 assignFunctionType->get_parameters().push_back( 672 new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), assignParamType->clone() ), 0 ) ); 673 assignFunctionType->get_parameters().push_back( 674 new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType, 0 ) ); 675 FunctionDecl *assignAssert = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignFunctionType, 0, false, false ); 676 dst->get_assertions().push_back( assignAssert ); 677 } 678 679 return dst; 680 } 681 661 682 Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) { 662 683 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false ); … … 666 687 std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters(); 667 688 std::list< Expression* > structParams; // List of matching parameters to put on types 689 TypeSubstitution genericSubs; // Substitutions to make to member types of struct 668 690 for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) { 669 691 isGeneric = true; 670 TypeDecl *typeParam = (*param)->clone();692 TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() ); 671 693 assignType->get_forall().push_back( typeParam ); 672 structParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) ); 694 TypeInstType *newParamType = new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ); 695 genericSubs.add( (*param)->get_name(), newParamType ); 696 structParams.push_back( new TypeExpr( newParamType ) ); 673 697 } 674 698 … … 701 725 } 702 726 703 if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) { 704 makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) ); 705 if ( isGeneric ) makeArrayAssignment( srcParam, returnVal, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) ); 727 if ( isGeneric ) { 728 // rewrite member type in terms of the type variables on this operator 729 DeclarationWithType *fixedMember = dwt->clone(); 730 genericSubs.apply( fixedMember ); 731 732 // assign to both destination and return value 733 if ( ArrayType *array = dynamic_cast< ArrayType * >( fixedMember->get_type() ) ) { 734 makeArrayAssignment( srcParam, dstParam, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) ); 735 makeArrayAssignment( srcParam, returnVal, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) ); 736 } else { 737 makeScalarAssignment( srcParam, dstParam, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) ); 738 makeScalarAssignment( srcParam, returnVal, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) ); 739 } // if 706 740 } else { 707 makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) ); 708 if ( isGeneric ) makeScalarAssignment( srcParam, returnVal, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) ); 741 // assign to destination 742 if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) { 743 makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) ); 744 } else { 745 makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) ); 746 } // if 709 747 } // if 710 748 } // if … … 724 762 for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) { 725 763 isGeneric = true; 726 TypeDecl *typeParam = (*param)->clone();764 TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() ); 727 765 assignType->get_forall().push_back( typeParam ); 728 766 unionParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) ); -
src/Tests/Makefile
r6ed1d4b r6ce67ce 8 8 OUTPUTS = ${addprefix ${OUTPUTDIR}/,${EXAMPLES:.c=.txt}} 9 9 10 .SILENT :10 #.SILENT : 11 11 12 12 all : … … 19 19 20 20 ${OUTPUTDIR}/%.txt : %.c ${CFA} Makefile 21 -${CFA} -n ${CFAOPT} <$< > $@ 2>&121 -${CFA} -n ${CFAOPT} $< > $@ 2>&1 22 22 23 23 ${OUTPUTDIR}/report : ${OUTPUTS} ${EXPECTDIR} -
src/examples/abs.c
r6ed1d4b r6ce67ce 10 10 // Created On : Thu Jan 28 18:26:16 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Feb 3 11:14:58201613 // Update Count : 4 312 // Last Modified On : Wed Feb 17 09:32:04 2016 13 // Update Count : 44 14 14 // 15 15 … … 18 18 19 19 int main( void ) { 20 ofstream *sout = ofstream_stdout();21 22 20 char ch = -65; 23 21 sout | "char\t\t\t" | ch | "\tabs " | abs( ch ) | endl; -
src/examples/alloc.c
r6ed1d4b r6ce67ce 11 11 // Created On : Wed Feb 3 07:56:22 2016 12 12 // Last Modified By : Peter A. Buhr 13 // Last Modified On : Wed Feb 3 16:32:04201614 // Update Count : 3813 // Last Modified On : Wed Feb 17 11:43:23 2016 14 // Update Count : 40 15 15 // 16 16 … … 27 27 28 28 int main( void ) { 29 ofstream * sout = ofstream_stdout();30 31 29 size_t size = 10; 32 30 int * p; … … 100 98 free( x ); 101 99 #endif 102 free( sout );103 100 } 104 101 -
src/examples/fstream_test.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jan 26 17:11:33 201613 // Update Count : 4 212 // Last Modified On : Wed Feb 17 11:45:43 2016 13 // Update Count : 43 14 14 // 15 15 … … 17 17 18 18 int main( void ) { 19 ofstream *sout = ofstream_stdout();20 ifstream *sin = ifstream_stdin();21 19 int nombre; 22 20 sout | "Entrez un nombre, s'il vous plaît:\n"; -
src/examples/hello.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jan 26 17:11:49201613 // Update Count : 712 // Last Modified On : Wed Feb 17 12:11:45 2016 13 // Update Count : 8 14 14 // 15 15 … … 17 17 18 18 int main() { 19 ofstream *sout = ofstream_stdout();20 ifstream *sin = ifstream_stdin();21 19 sout | "Bonjour au monde!\n"; 22 20 } -
src/examples/identity.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jan 26 17:11:58201613 // Update Count : 812 // Last Modified On : Wed Feb 17 12:17:32 2016 13 // Update Count : 10 14 14 // 15 15 … … 22 22 23 23 int main() { 24 ofstream *sout = ofstream_stdout();25 24 sout | "char\t\t\t" | identity( 'z' ) | endl; 26 25 sout | "signed int\t\t" | identity( 4 ) | endl; … … 30 29 sout | "signed long long int\t" | identity( 4ll ) | endl; 31 30 sout | "unsigned long long int\t" | identity( 4ull ) | endl; 32 sout | "float\t\t\t" | identity( 4. 0f ) | endl;33 sout | "double\t\t\t" | identity( 4. 0) | endl;34 sout | "long double\t\t" | identity( 4. 0l ) | endl;31 sout | "float\t\t\t" | identity( 4.1f ) | endl; 32 sout | "double\t\t\t" | identity( 4.1 ) | endl; 33 sout | "long double\t\t" | identity( 4.1l ) | endl; 35 34 } 36 35 -
src/examples/minmax.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Feb 3 11:14:49201613 // Update Count : 4 612 // Last Modified On : Wed Feb 17 12:17:53 2016 13 // Update Count : 47 14 14 // 15 15 … … 18 18 19 19 int main( void ) { 20 ofstream *sout = ofstream_stdout();21 20 // char does not have less or greater than. 22 21 int ?<?( char op1, char op2 ) { return (int)op1 < (int)op2; } -
src/examples/quad.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jan 26 17:13:48201613 // Update Count : 512 // Last Modified On : Wed Feb 17 12:19:24 2016 13 // Update Count : 6 14 14 // 15 15 … … 27 27 28 28 int main() { 29 ofstream *sout = ofstream_stdout();30 29 int N = 2; 31 30 sout | "result of quad of " | N | " is " | quad( N ) | endl; -
src/examples/quoted_keyword.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jan 26 17:13:58201613 // Update Count : 812 // Last Modified On : Wed Feb 17 12:19:45 2016 13 // Update Count : 9 14 14 // 15 15 … … 28 28 29 29 int main() { 30 ofstream *sout = ofstream_stdout();31 30 sout | `catch` + st.`type` + st.`struct` + `throw` | endl; 32 31 } -
src/examples/random.c
r6ed1d4b r6ce67ce 7 7 8 8 int main() { 9 ofstream *sout = ofstream_stdout();10 11 9 randseed( getpid() ); // set random seed 12 10 -
src/examples/square.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jan 26 17:14:16201613 // Update Count : 2 512 // Last Modified On : Wed Feb 17 12:21:58 2016 13 // Update Count : 26 14 14 // 15 15 … … 23 23 int main() { 24 24 #if 0 25 ofstream *sout = ofstream_stdout();26 25 sout | "result of squaring 9 is " | endl; 27 26 -
src/examples/sum.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Feb 5 16:47:44201613 // Update Count : 1 3912 // Last Modified On : Tue Feb 16 23:49:31 2016 13 // Update Count : 189 14 14 // 15 15 … … 33 33 34 34 // Required to satisfy sumable as char does not have addition. 35 // const char 0; 36 // char ?+?( char op1, char op2 ) { return (int)op1 + op2; } // cast forces integer addition or recursion 37 // char ++?( char *op ) { *op += 1; return *op; } 38 // char ?++( char *op ) { char temp = *op; *op += 1; return temp; } 35 const char 0; 36 char ?+?( char t1, char t2 ) { return (int)t1 + t2; } // cast forces integer addition, otherwise recursion 37 char ?+=?( char *t1, char t2 ) { *t1 = *t1 + t2; return *t1; } 38 char ++?( char *t ) { *t += 1; return *t; } 39 char ?++( char *t ) { char temp = *t; *t += 1; return temp; } 39 40 40 41 int main( void ) { 41 42 const int low = 5, High = 15, size = High - low; 42 ofstream *sout = ofstream_stdout();43 #if 044 43 45 char s = 0, a[size]; 46 char v = low; 44 char s = 0, a[size], v = low; 47 45 for ( int i = 0; i < size; i += 1, v += 1 ) { 48 46 s += v; 49 47 a[i] = v; 50 } 48 } // for 51 49 sout | "sum from " | low | " to " | High | " is " 52 50 | (int)sum( size, a ) | ", check " | (int)s | endl; 53 51 54 int s = 0, a[size]; 55 int v = low; 52 int s = 0, a[size], v = low; 56 53 for ( int i = 0; i < size; i += 1, v += 1 ) { 57 54 s += (int)v; 58 55 a[i] = (int)v; 59 } 56 } // for 60 57 sout | "sum from " | low | " to " | High | " is " 61 58 | sum( size, (int *)a ) | ", check " | (int)s | endl; 62 59 63 float s = 0.0, a[size]; 64 float v = low / 10.0; 60 float s = 0.0, a[size], v = low / 10.0; 65 61 for ( int i = 0; i < size; i += 1, v += 0.1f ) { 66 62 s += (float)v; 67 63 a[i] = (float)v; 68 } 64 } // for 69 65 sout | "sum from " | low / 10.0 | " to " | High / 10.0 | " is " 70 66 | sum( size, (float *)a ) | ", check " | (float)s | endl; 71 #endif72 double s = 0, a[size];73 double v = low / 10.0;74 67 68 double s = 0, a[size], v = low / 10.0; 75 69 for ( int i = 0; i < size; i += 1, v += 0.1 ) { 76 70 s += (double)v; 77 71 a[i] = (double)v; 78 } 72 } // for 79 73 sout | "sum from " | low / 10.0 | " to " | High / 10.0 | " is " 80 74 | sum( size, (double *)a ) | ", check " | (double)s | endl; 81 75 82 // struct S { int i, j; } sarr[size]; 83 // struct S 0 = { 0, 0 }; 84 // struct S 1 = { 1, 1 }; 85 // S ?+?( S t1, S t2 ) { S s = { t1.i + t1.j, t2.i + t2.j }; return s; } 86 // S ?+=?( S *t1, S t2 ) { *t1 = *t1 + t2; return *t1; } 87 // S ++?( S *t ) { *t += 1; return *t; } 88 // S ?++( S *t ) { S temp = *t; *t += 1; return temp; } 89 // sum( size, sarr ); 76 struct S { int i, j; } 0 = { 0, 0 }, 1 = { 1, 1 }; 77 S ?+?( S t1, S t2 ) { S s = { t1.i + t2.i, t1.j + t2.j }; return s; } 78 S ?+=?( S *t1, S t2 ) { *t1 = *t1 + t2; return *t1; } 79 S ++?( S *t ) { *t += 1; return *t; } 80 S ?++( S *t ) { S temp = *t; *t += 1; return temp; } 81 ofstream * ?|?( ofstream * os, S v ) { return os | v.i | ' ' | v.j; } 82 83 S s = 0, a[size], v = { low, low }; 84 for ( int i = 0; i < size; i += 1, v += (S)1 ) { 85 s += (S)v; 86 a[i] = (S)v; 87 } // for 88 sout | "sum from " | low | " to " | High | " is " 89 | sum( size, (S *)a ) | ", check " | (S)s | endl; 90 90 } // main 91 91 -
src/examples/swap.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Feb 3 11:14:04201613 // Update Count : 6 312 // Last Modified On : Wed Feb 17 12:22:12 2016 13 // Update Count : 64 14 14 // 15 15 … … 18 18 19 19 int main( void ) { 20 ofstream *sout = ofstream_stdout();21 22 20 char c1 = 'a', c2 = 'b'; 23 21 sout | "char\t\t\t" | c1 | ' ' | c2 | "\t\t\tswap "; -
src/examples/twice.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jan 26 17:14:44201613 // Update Count : 1 212 // Last Modified On : Wed Feb 17 12:23:25 2016 13 // Update Count : 13 14 14 // 15 15 … … 27 27 char ?++( char *op ) { char temp = *op; *op += 1; return temp; } 28 28 29 ofstream *sout = ofstream_stdout();30 29 sout | twice( 'a' ) | ' ' | twice( 1 ) | ' ' | twice( 3.2 ) | endl; 31 30 } -
src/examples/vector_test.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jan 26 17:14:52201613 // Update Count : 1 712 // Last Modified On : Wed Feb 17 12:23:55 2016 13 // Update Count : 18 14 14 // 15 15 … … 20 20 21 21 int main( void ) { 22 ofstream *sout = ofstream_stdout();23 ifstream *sin = ifstream_stdin();24 22 vector_int vec = vector_int_allocate(); 25 23 -
src/libcfa/fstream
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Jan 27 23:47:41 201613 // Update Count : 312 // Last Modified On : Wed Feb 17 14:02:01 2016 13 // Update Count : 22 14 14 // 15 15 … … 19 19 #include "iostream" 20 20 21 typedef struct ofstream ofstream; 21 // implement context ostream 22 struct ofstream; 22 23 23 // implement context ostream 24 ofstream *write( ofstream *, const char *, streamsize_type ); 25 int fail( ofstream * ); 24 int fail( ofstream * os ); 25 int flush( ofstream * os ); 26 void open( ofstream ** os, const char * name, const char * mode ); 27 void close( ofstream * os ); 28 ofstream * write( ofstream * os, const char * data, streamsize_type size ); 26 29 27 ofstream *ofstream_stdout(); 28 ofstream *ofstream_stderr(); 29 ofstream *ofstream_fromfile( const char *name ); 30 void ofstream_close( ofstream *os ); 31 32 typedef struct ifstream ifstream; 30 extern ofstream * sout, * serr; 33 31 34 32 // implement context istream 35 ifstream *read( ifstream *, char *, streamsize_type ); 36 ifstream *unread( ifstream *, char ); 37 int fail( ifstream * ); 38 int eof( ifstream * ); 33 struct ifstream; 39 34 40 ifstream *ifstream_stdin(); 41 ifstream *ifstream_fromfile( const char *name ); 35 int fail( ifstream * is ); 36 int eof( ifstream * is ); 37 void open( ifstream ** is, const char * name, const char * mode ); 38 void close( ifstream * is ); 39 ifstream * get( ifstream * is, int * data ); 40 ifstream * read( ifstream * is, char * data, streamsize_type size ); 41 ifstream * ungetc( ifstream * is, char c ); 42 43 extern ifstream *sin; 42 44 43 45 #endif // __FSTREAM_H__ -
src/libcfa/fstream.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jan 26 17:12:59201613 // Update Count : 612 // Last Modified On : Wed Feb 17 14:03:05 2016 13 // Update Count : 76 14 14 // 15 15 … … 23 23 struct ofstream { 24 24 FILE *file; 25 int fail;26 25 }; 27 26 28 ofstream *write( ofstream *os, const char *data, streamsize_type size ) { 29 if ( ! os->fail ) { 30 fwrite( data, size, 1, os->file ); 31 os->fail = ferror( os->file ); 27 #define IO_MSG "I/O error " 28 29 int fail( ofstream * os ) { 30 return ferror( os->file ); 31 } // fail 32 33 int flush( ofstream * os ) { 34 return fflush( os->file ); 35 } // flush 36 37 void open( ofstream ** os, const char * name, const char * mode ) { 38 FILE *t = fopen( name, mode ); 39 if ( t == 0 ) { // do not change unless successful 40 perror( IO_MSG "open output" ); 41 exit( EXIT_FAILURE ); 42 } // if 43 (*os)->file = t; 44 } // open 45 46 void close( ofstream * os ) { 47 if ( os->file == stdout || os->file == stderr ) return; 48 49 if ( fclose( os->file ) == EOF ) { 50 perror( IO_MSG "close output" ); 51 } // if 52 } // close 53 54 ofstream * write( ofstream * os, const char * data, streamsize_type size ) { 55 if ( fail( os ) ) { 56 fprintf( stderr, "attempt write I/O on failed stream\n" ); 57 exit( EXIT_FAILURE ); 58 } // if 59 60 if ( fwrite( data, 1, size, os->file ) != size ) { 61 perror( IO_MSG "write" ); 62 exit( EXIT_FAILURE ); 32 63 } // if 33 64 return os; 34 65 } // write 35 66 36 int fail( ofstream *os ) { 37 return os->fail; 38 } // fail 67 static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_) }; 68 ofstream *sout = &soutFile; 69 static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_) }; 70 ofstream *serr = &serrFile; 39 71 40 static ofstream *make_ofstream() { 41 ofstream *new_stream = malloc( sizeof( ofstream ) ); 42 new_stream->fail = 0; 43 return new_stream; 44 } // make_ofstream 45 46 ofstream *ofstream_stdout() { 47 ofstream *stdout_stream = make_ofstream(); 48 stdout_stream->file = stdout; 49 return stdout_stream; 50 } // ofstream_stdout 51 52 ofstream *ofstream_stderr() { 53 ofstream *stderr_stream = make_ofstream(); 54 stderr_stream->file = stderr; 55 return stderr_stream; 56 } // ofstream_stderr 57 58 ofstream *ofstream_fromfile( const char *name ) { 59 ofstream *file_stream = make_ofstream(); 60 file_stream->file = fopen( name, "w" ); 61 file_stream->fail = file_stream->file == 0; 62 return file_stream; 63 } 64 65 void ofstream_close( ofstream *os ) { 66 if ( os->file != stdout && os->file != stderr ) { 67 os->fail = fclose( os->file ); 68 } 69 free( os ); 70 } 72 //--------------------------------------- 71 73 72 74 struct ifstream { 73 75 FILE *file; 74 int fail;75 int eof;76 76 }; 77 77 78 ifstream *read( ifstream *is, char *data, streamsize_type size ) { 79 if ( ! is->fail && ! is->eof ) { 80 fread( data, size, 1, is->file ); 81 is->fail = ferror( is->file ); 82 is->eof = feof( is->file ); 83 } 78 int fail( ifstream * is ) { 79 return ferror( is->file ); 80 } // fail 81 82 int eof( ifstream * is ) { 83 return feof( is->file ); 84 } // eof 85 86 ifstream * get( ifstream * is, int * data ) { 87 if ( fscanf( is->file, "%d", data ) == EOF ) { 88 if ( ferror( is->file ) ) { 89 fprintf( stderr, "invalid int read\n" ); 90 exit( EXIT_FAILURE ); 91 } // if 92 } // if 84 93 return is; 85 } 94 } // read 95 96 ifstream * read( ifstream * is, char * data, streamsize_type size ) { 97 if ( fail( is ) ) { 98 fprintf( stderr, "attempt read I/O on failed stream\n" ); 99 exit( EXIT_FAILURE ); 100 } // if 101 102 if ( fread( data, size, 1, is->file ) == 0 ) { 103 perror( IO_MSG "read" ); 104 exit( EXIT_FAILURE ); 105 } // if 106 return is; 107 } // read 86 108 87 ifstream *unread( ifstream *is, char c ) { 88 if ( ! is->fail ) { 89 if ( ! EOF == ungetc( c, is->file ) ) { 90 is->fail = 1; 91 } 92 } 109 ifstream *ungetc( ifstream * is, char c ) { 110 if ( fail( is ) ) { 111 fprintf( stderr, "attempt ungetc I/O on failed stream\n" ); 112 exit( EXIT_FAILURE ); 113 } // if 114 115 if ( ungetc( c, is->file ) == EOF ) { 116 perror( IO_MSG "ungetc" ); 117 exit( EXIT_FAILURE ); 118 } // if 93 119 return is; 94 } 120 } // ungetc 95 121 96 int fail( ifstream *is ) { 97 return is->fail; 98 } 122 void open( ifstream ** is, const char * name, const char * mode ) { 123 FILE *t = fopen( name, mode ); 124 if ( t == 0 ) { // do not change unless successful 125 perror( IO_MSG "open input" ); 126 exit( EXIT_FAILURE ); 127 } // if 128 (*is)->file = t; 129 } // open 99 130 100 int eof( ifstream *is ) { 101 return is->eof; 102 } 131 void close( ifstream * is ) { 132 if ( is->file == stdin ) return; 103 133 104 static ifstream *make_ifstream() { 105 ifstream *new_stream = malloc( sizeof( ifstream ) ); 106 new_stream->fail = 0; 107 new_stream->eof = 0; 108 return new_stream; 109 } 134 if ( fclose( is->file ) == EOF ) { 135 perror( IO_MSG "close input" ); 136 } // if 137 } // close 110 138 111 ifstream *ifstream_stdin() { 112 ifstream *stdin_stream = make_ifstream(); 113 stdin_stream->file = stdin; 114 return stdin_stream; 115 } 116 117 ifstream *ifstream_fromfile( const char *name ) { 118 ifstream *file_stream = make_ifstream(); 119 file_stream->file = fopen( name, "r" ); 120 file_stream->fail = file_stream->file == 0; 121 return file_stream; 122 } 139 static ifstream sinFile = { (FILE *)(&_IO_2_1_stdin_) }; 140 ifstream *sin = &sinFile; 123 141 124 142 // Local Variables: // -
src/libcfa/iostream
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Jan 29 15:50:36201613 // Update Count : 2912 // Last Modified On : Wed Feb 17 14:04:24 2016 13 // Update Count : 32 14 14 // 15 15 … … 22 22 23 23 context ostream( dtype ostype ) { 24 ostype *write( ostype *, const char *, streamsize_type );25 24 int fail( ostype * ); 25 int flush( ostype * ); 26 ostype * write( ostype *, const char *, streamsize_type ); 26 27 }; 27 28 28 context writeable( type T ) { 29 29 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T ); … … 52 52 53 53 // writes the range [begin, end) to the given stream 54 forall( type elt_type | writeable( elt_type ), 55 type iterator_type | iterator( iterator_type, elt_type ), 56 dtype os_type | ostream( os_type ) ) 54 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) ) 57 55 void write( iterator_type begin, iterator_type end, os_type *os ); 58 56 59 forall( type elt_type | writeable( elt_type ), 60 type iterator_type | iterator( iterator_type, elt_type ), 61 dtype os_type | ostream( os_type ) ) 57 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) ) 62 58 void write_reverse( iterator_type begin, iterator_type end, os_type *os ); 63 59 64 // ******************************************************************************60 //--------------------------------------- 65 61 66 62 context istream( dtype istype ) { 67 istype *read( istype *, char *, streamsize_type );68 istype *unread( istype *, char );69 63 int fail( istype * ); 70 64 int eof( istype * ); 65 istype * get( istype *, int * ); 66 istype * read( istype *, char *, streamsize_type ); 67 istype * ungetc( istype *, char ); 71 68 }; 72 69 -
src/libcfa/iostream.c
r6ed1d4b r6ce67ce 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon Feb 1 14:20:30201613 // Update Count : 6012 // Last Modified On : Wed Feb 17 14:19:56 2016 13 // Update Count : 76 14 14 // 15 15 … … 19 19 #include <stdio.h> 20 20 #include <string.h> // strlen 21 #include <float.h> // DBL_DIG, LDBL_DIG 21 22 #include <complex.h> // creal, cimag 22 23 } … … 72 73 ostype * ?|?( ostype *os, double d ) { 73 74 char buffer[32]; 74 return write( os, buffer, sprintf( buffer, "% g", d ) );75 return write( os, buffer, sprintf( buffer, "%.*lg", DBL_DIG, d ) ); 75 76 } // ?|? 76 77 … … 78 79 ostype * ?|?( ostype *os, long double d ) { 79 80 char buffer[32]; 80 return write( os, buffer, sprintf( buffer, "% Lg", d ) );81 return write( os, buffer, sprintf( buffer, "%.*Lg", LDBL_DIG, d ) ); 81 82 } // ?|? 82 83 … … 110 111 forall( dtype ostype, dtype retostype | ostream( ostype ) | ostream( retostype ) ) 111 112 retostype * ?|?( ostype *os, retostype * (*manip)(ostype*) ) { 112 return manip( os);113 return manip( os ); 113 114 } 114 115 115 116 forall( dtype ostype | ostream( ostype ) ) 116 117 ostype * endl( ostype * os ) { 117 118 // flush 119 118 os | "\n"; 119 flush( os ); 120 return os; 120 121 } // endl 121 122 122 forall( type elt_type | writeable( elt_type ), 123 type iterator_type | iterator( iterator_type, elt_type ), 123 //--------------------------------------- 124 125 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), 124 126 dtype os_type | ostream( os_type ) ) 125 127 void write( iterator_type begin, iterator_type end, os_type *os ) { 126 void print( elt_type i ) { 127 os | i | ' '; 128 } 128 void print( elt_type i ) { os | i | ' '; } 129 129 for_each( begin, end, print ); 130 130 } // ?|? 131 131 132 forall( type elt_type | writeable( elt_type ), 133 type iterator_type | iterator( iterator_type, elt_type ), 132 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), 134 133 dtype os_type | ostream( os_type ) ) 135 134 void write_reverse( iterator_type begin, iterator_type end, os_type *os ) { … … 138 137 } // ?|? 139 138 139 //--------------------------------------- 140 140 141 141 forall( dtype istype | istream( istype ) ) … … 146 146 forall( dtype istype | istream( istype ) ) 147 147 istype * ?|?( istype *is, int *ip ) { 148 char cur; 149 150 // skip some whitespace 151 do { 152 is | &cur; 153 if ( fail( is ) || eof( is ) ) return is; 154 } while ( !( cur >= '0' && cur <= '9' ) ); 155 156 // accumulate digits 157 *ip = 0; 158 while ( cur >= '0' && cur <= '9' ) { 159 *ip = *ip * 10 + ( cur - '0' ); 160 is | &cur; 161 if ( fail( is ) || eof( is ) ) return is; 162 } 163 164 unread( is, cur ); 165 return is; 148 return get( is, ip ); 166 149 } // ?|? 167 150 -
src/libcfa/stdlib.c
r6ed1d4b r6ce67ce 10 10 // Created On : Thu Jan 28 17:10:29 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Feb 5 15:41:24201613 // Update Count : 1 2812 // Last Modified On : Wed Feb 10 15:45:56 2016 13 // Update Count : 140 14 14 // 15 15 … … 23 23 #include <string.h> // memset 24 24 #include <malloc.h> // malloc_usable_size 25 #include <stdio.h>26 25 #include <math.h> // fabsf, fabs, fabsl 27 26 #include <complex.h> // _Complex_I, cabsf, cabs, cabsl … … 106 105 long int ato( const char * ptr ) { 107 106 long int li; 108 if ( sscanf( ptr, "%ld", &li ) == EOF ) {} ;// check return code107 if ( sscanf( ptr, "%ld", &li ) == EOF ) {} // check return code 109 108 return li; 110 109 } 111 110 unsigned long int ato( const char * ptr ) { 112 111 unsigned long int uli; 113 if ( sscanf( ptr, "%lu", &uli ) == EOF ) {} ;// check return code112 if ( sscanf( ptr, "%lu", &uli ) == EOF ) {} // check return code 114 113 return uli; 115 114 } 116 115 long long int ato( const char * ptr ) { 117 116 long long int lli; 118 if ( sscanf( ptr, "%lld", &lli ) == EOF ) {} ;// check return code117 if ( sscanf( ptr, "%lld", &lli ) == EOF ) {} // check return code 119 118 return lli; 120 119 } 121 120 unsigned long long int ato( const char * ptr ) { 122 121 unsigned long long int ulli; 123 if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {} ;// check return code122 if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {} // check return code 124 123 return ulli; 125 124 } 126 125 float ato( const char * ptr ) { 127 126 float f; 128 if ( sscanf( ptr, "%f", &f ) == EOF ) {} ;// check return code127 if ( sscanf( ptr, "%f", &f ) == EOF ) {} // check return code 129 128 return f; 130 129 } 131 130 double ato( const char * ptr ) { 132 131 double d; 133 if ( sscanf( ptr, "%lf", &d ) == EOF ) {} ;// check return code132 if ( sscanf( ptr, "%lf", &d ) == EOF ) {} // check return code 134 133 return d; 135 134 } 136 135 long double ato( const char * ptr ) { 137 136 long double ld; 138 printf( "FRED " ); 139 if ( sscanf( ptr, "%.32Lf", &ld ) == EOF ) {}; // check return code 137 if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {} // check return code 140 138 return ld; 141 139 } 142 140 float _Complex ato( const char * ptr ) { 143 141 float re, im; 144 if ( sscanf( ptr, "%g%g ", &re, &im ) == EOF ) {};// check return code142 if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {} // check return code 145 143 return re + im * _Complex_I; 146 144 } 147 145 double _Complex ato( const char * ptr ) { 148 146 double re, im; 149 if ( sscanf( ptr, "% .16lg%.16lg", &re, &im ) == EOF ) {};// check return code147 if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {} // check return code 150 148 return re + im * _Complex_I; 151 149 } 152 150 long double _Complex ato( const char * ptr ) { 153 151 long double re, im; 154 if ( sscanf( ptr, "% .32Lg%.32Lg", &re, &im ) == EOF ) {};// check return code152 if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {} // check return code 155 153 return re + im * _Complex_I; 156 154 }
Note: See TracChangeset
for help on using the changeset viewer.