Changes in / [ae7f1e0:c44e622]

Location:

src

Files:

• GenPoly/Box.cc (modified) (23 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (22 diffs)
• ResolvExpr/CastCost.cc (modified) (3 diffs)
• ResolvExpr/Resolver.cc (modified) (3 diffs)
• ResolvExpr/TypeMap.h (deleted)
• SymTab/Validate.cc (modified) (5 diffs)
• Tests/Makefile (modified) (2 diffs)
• examples/abs.c (modified) (2 diffs)
• examples/alloc.c (modified) (3 diffs)
• examples/ato.c (deleted)
• examples/fstream_test.c (modified) (2 diffs)
• examples/hello.c (modified) (2 diffs)
• examples/identity.c (modified) (3 diffs)
• examples/minmax.c (modified) (2 diffs)
• examples/quad.c (modified) (2 diffs)
• examples/quoted_keyword.c (modified) (2 diffs)
• examples/random.c (modified) (1 diff)
• examples/searchsort.c (deleted)
• examples/square.c (modified) (2 diffs)
• examples/sum.c (modified) (2 diffs)
• examples/swap.c (modified) (2 diffs)
• examples/twice.c (modified) (2 diffs)
• examples/vector_test.c (modified) (2 diffs)
• libcfa/fstream (modified) (2 diffs)
• libcfa/fstream.c (modified) (2 diffs)
• libcfa/iostream (modified) (3 diffs)
• libcfa/iostream.c (modified) (7 diffs)
• libcfa/stdlib.c (modified) (3 diffs)

src/GenPoly/Box.cc

@@ -25 +25 @@
 #include "PolyMutator.h"
 #include "FindFunction.h"
+#include "ScopedMap.h"
 #include "ScrubTyVars.h"
 
@@ -37 +38 @@
 
 #include "ResolvExpr/TypeEnvironment.h"
-#include "ResolvExpr/TypeMap.h"
-#include "ResolvExpr/typeops.h"
 
 #include "SymTab/Mangler.h"
@@ -74 +73 @@
                         /// Makes a new temporary array holding the offsets of the fields of `type`, and returns a new variable expression referencing it
                         Expression *makeOffsetArray( StructInstType *type );
-                        /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
-                        void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
                         /// passes extra type parameters into a polymorphic function application
-                        void passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
+                        void passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
                         Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
@@ -102 +99 @@
                         typedef std::map< std::string, DeclarationWithType *> AdapterMap;
                         std::map< std::string, DeclarationWithType *> assignOps;
-                        ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;
+                        ScopedMap< std::string, DeclarationWithType *> scopedAssignOps;
                         std::stack< AdapterMap > adapters;
                         DeclarationWithType *retval;
@@ -249 +246 @@
                 }
 
-                /// Returns T if the given declaration is (*?=?)(T *, T) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
-                TypeInstType *isTypeInstAssignment( DeclarationWithType *decl ) {
+                /// returns T if the given declaration is: (*?=?)(T *, T) for some T (return not checked, but maybe should be), NULL otherwise
+                ReferenceToType *isAssignment( DeclarationWithType *decl ) {
                         if ( decl->get_name() == "?=?" ) {
                                 if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
                                         if ( funType->get_parameters().size() == 2 ) {
                                                 if ( PointerType *pointer = dynamic_cast< PointerType *>( funType->get_parameters().front()->get_type() ) ) {
-                                                        if ( TypeInstType *refType = dynamic_cast< TypeInstType *>( pointer->get_base() ) ) {
-                                                                if ( TypeInstType *refType2 = dynamic_cast< TypeInstType *>( funType->get_parameters().back()->get_type() ) ) {
+                                                        if ( ReferenceToType *refType = dynamic_cast< ReferenceToType *>( pointer->get_base() ) ) {
+                                                                if ( ReferenceToType *refType2 = dynamic_cast< ReferenceToType *>( funType->get_parameters().back()->get_type() ) ) {
                                                                         if ( refType->get_name() == refType2->get_name() ) {
                                                                                 return refType;
@@ -268 +265 @@
                         return 0;
                 }
-                
-                /// returns T if the given declaration is: (*?=?)(T *, T) for some type T (return not checked, but maybe should be), NULL otherwise
-                /// Only picks assignments where neither parameter is cv-qualified
-                Type *isAssignment( DeclarationWithType *decl ) {
-                        if ( decl->get_name() == "?=?" ) {
-                                if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
-                                        if ( funType->get_parameters().size() == 2 ) {
-                                                Type::Qualifiers defaultQualifiers;
-                                                Type *paramType1 = funType->get_parameters().front()->get_type();
-                                                if ( paramType1->get_qualifiers() != defaultQualifiers ) return 0;
-                                                Type *paramType2 = funType->get_parameters().back()->get_type();
-                                                if ( paramType2->get_qualifiers() != defaultQualifiers ) return 0;
-                                                
-                                                if ( PointerType *pointerType = dynamic_cast< PointerType* >( paramType1 ) ) {
-                                                        Type *baseType1 = pointerType->get_base();
-                                                        if ( baseType1->get_qualifiers() != defaultQualifiers ) return 0;
-                                                        SymTab::Indexer dummy;
-                                                        if ( ResolvExpr::typesCompatible( baseType1, paramType2, dummy ) ) {
-                                                                return baseType1;
-                                                        } // if
-                                                } // if
-                                        } // if
-                                } // if
-                        } // if
-                        return 0;
-                }
 
                 void Pass1::findAssignOps( const std::list< TypeDecl *> &forall ) {
@@ -301 +272 @@
                                 for ( std::list< DeclarationWithType *>::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
                                         std::string typeName;
-                                        if ( TypeInstType *typeInst = isTypeInstAssignment( *assert ) ) {
+                                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( isAssignment( *assert ) ) ) {
                                                 assignOps[ typeInst->get_name() ] = *assert;
                                         } // if
@@ -310 +281 @@
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
                         // if this is a polymorphic assignment function, put it in the map for this scope
-                        if ( Type *assignedType = isAssignment( functionDecl ) ) {
-                                if ( ! dynamic_cast< TypeInstType* >( assignedType ) ) {
-                                        scopedAssignOps.insert( assignedType, functionDecl );
+                        if ( ReferenceToType *refType = isAssignment( functionDecl ) ) {
+                                if ( ! dynamic_cast< TypeInstType* >( refType ) ) {
+                                        scopedAssignOps.insert( refType->get_name(), functionDecl );
                                 }
                         }
@@ -427 +398 @@
                 }
 
-                void Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) {
-                        Type *polyBase = hasPolyBase( parmType, exprTyVars );
-                        if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) {
-                                std::string sizeName = sizeofName( polyBase );
-                                if ( seenTypes.count( sizeName ) ) return;
-
-                                arg = appExpr->get_args().insert( arg, new SizeofExpr( argBaseType->clone() ) );
-                                arg++;
-                                arg = appExpr->get_args().insert( arg, new AlignofExpr( argBaseType->clone() ) );
-                                arg++;
-                                if ( dynamic_cast< StructInstType* >( polyBase ) ) {
-                                        if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) {
-                                                arg = appExpr->get_args().insert( arg, makeOffsetArray( argBaseStructType ) );
-                                                arg++;
-                                        } else {
-                                                throw SemanticError( "Cannot pass non-struct type for generic struct" );
-                                        }
-                                }
-
-                                seenTypes.insert( sizeName );
-                        }
-                }
-
-                void Pass1::passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
+                void Pass1::passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
                         // pass size/align for type variables
                         for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
@@ -476 +424 @@
                         std::list< Expression* >::const_iterator fnArg = arg;
                         std::set< std::string > seenTypes; //< names for generic types we've seen
-
-                        // a polymorphic return type may need to be added to the argument list
-                        if ( polyRetType ) {
-                                Type *concRetType = replaceWithConcrete( appExpr, polyRetType );
-                                passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
-                        }
-                        
-                        // add type information args for presently unseen types in parameter list
                         for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
-                                VariableExpr *fnArgBase = getBaseVar( *fnArg );
-                                if ( ! fnArgBase || fnArgBase->get_results().empty() ) continue;
-                                passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_results().front(), arg, exprTyVars, seenTypes );
+                                Type *polyBase = hasPolyBase( (*fnParm)->get_type(), exprTyVars );
+                                if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) {
+                                        std::string sizeName = sizeofName( polyBase );
+                                        if ( seenTypes.count( sizeName ) ) continue;
+
+                                        VariableExpr *fnArgBase = getBaseVar( *fnArg );
+                                        assert( fnArgBase && ! fnArgBase->get_results().empty() );
+                                        Type *argBaseType = fnArgBase->get_results().front();
+                                        arg = appExpr->get_args().insert( arg, new SizeofExpr( argBaseType->clone() ) );
+                                        arg++;
+                                        arg = appExpr->get_args().insert( arg, new AlignofExpr( argBaseType->clone() ) );
+                                        arg++;
+                                        if ( dynamic_cast< StructInstType* >( polyBase ) ) {
+                                                if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) {
+                                                        arg = appExpr->get_args().insert( arg, makeOffsetArray( argBaseStructType ) );
+                                                        arg++;
+                                                } else {
+                                                        throw SemanticError( "Cannot pass non-struct type for generic struct" );
+                                                }
+                                        }
+
+                                        seenTypes.insert( sizeName );
+                                }
                         }
                 }
@@ -510 +470 @@
                         ObjectDecl *newObj = makeTemporary( retType->clone() );
                         Expression *paramExpr = new VariableExpr( newObj );
-
-                        // If the type of the temporary is not polymorphic, box temporary by taking its address;
-                        // otherwise the temporary is already boxed and can be used directly.
+                        // If the type of the temporary is not polymorphic, box temporary by taking its address; otherwise the
+                        // temporary is already boxed and can be used directly.
                         if ( ! isPolyType( newObj->get_type(), scopeTyVars, env ) ) {
                                 paramExpr = new AddressExpr( paramExpr );
@@ -561 +520 @@
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, polyType );
-                        // add out-parameter for return value   
                         return addRetParam( appExpr, function, concrete, arg );
                 }
@@ -584 +542 @@
                         assert( ! arg->get_results().empty() );
                         if ( isPolyType( param, exprTyVars ) ) {
-                                if ( isPolyType( arg->get_results().front() ) ) {
-                                        // if the argument's type is polymorphic, we don't need to box again!
+                                if ( dynamic_cast< TypeInstType *>( arg->get_results().front() ) ) {
+                                        // if the argument's type is a type parameter, we don't need to box again!
                                         return;
                                 } else if ( arg->get_results().front()->get_isLvalue() ) {
@@ -664 +622 @@
                         assert( arg );
                         if ( isPolyType( realParam->get_type(), tyVars ) ) {
-                                if ( ! isPolyType( arg->get_type() ) ) {
+                                if ( dynamic_cast<TypeInstType *>(arg->get_type()) == NULL ) {
                                         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
                                         deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
@@ -959 +917 @@
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
 
-                        TyVarMap exprTyVars;
-                        makeTyVarMap( function, exprTyVars );
-                        ReferenceToType *polyRetType = isPolyRet( function );
-
-                        if ( polyRetType ) {
-                                ret = addPolyRetParam( appExpr, function, polyRetType, arg );
+                        if ( ReferenceToType *polyType = isPolyRet( function ) ) {
+                                ret = addPolyRetParam( appExpr, function, polyType, arg );
                         } else if ( needsAdapter( function, scopeTyVars ) ) {
                                 // std::cerr << "needs adapter: ";
@@ -976 +930 @@
                         arg = appExpr->get_args().begin();
 
-                        passTypeVars( appExpr, polyRetType, arg, exprTyVars );
+                        TyVarMap exprTyVars;
+                        makeTyVarMap( function, exprTyVars );
+
+                        passTypeVars( appExpr, arg, exprTyVars );
                         addInferredParams( appExpr, function, arg, exprTyVars );
 
@@ -1035 +992 @@
                 }
 
-                /// Wraps a function declaration in a new pointer-to-function variable expression
-                VariableExpr *wrapFunctionDecl( DeclarationWithType *functionDecl ) {
-                        // line below cloned from FixFunction.cc
-                        ObjectDecl *functionObj = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0,
-                                                                  new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
-                        functionObj->set_mangleName( functionDecl->get_mangleName() );
-                        return new VariableExpr( functionObj );
-                }
-                
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->get_expr() ) {
@@ -1059 +1007 @@
 
                                 // find assignment operator for (polymorphic) return type
-                                ApplicationExpr *assignExpr = 0;
+                                DeclarationWithType *assignDecl = 0;
                                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() ) ) {
-                                        // find assignment operator for type variable
                                         std::map< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
                                         if ( assignIter == assignOps.end() ) {
                                                 throw SemanticError( "Attempt to return dtype or ftype object in ", returnStmt->get_expr() );
                                         } // if
-                                        assignExpr = new ApplicationExpr( new VariableExpr( assignIter->second ) );
+                                        assignDecl = assignIter->second;
                                 } else if ( ReferenceToType *refType = dynamic_cast< ReferenceToType *>( retval->get_type() ) ) {
-                                        // find assignment operator for generic type
-                                        DeclarationWithType *functionDecl = scopedAssignOps.find( refType );
-                                        if ( ! functionDecl ) {
+                                        ScopedMap< std::string, DeclarationWithType *>::const_iterator assignIter = scopedAssignOps.find( refType->get_name() );
+                                        if ( assignIter == scopedAssignOps.end() ) {
                                                 throw SemanticError( "Attempt to return dtype or ftype generic object in ", returnStmt->get_expr() );
                                         }
-
-                                        // wrap it up in an application expression
-                                        assignExpr = new ApplicationExpr( wrapFunctionDecl( functionDecl ) );
-                                        assignExpr->set_env( env->clone() );
-
-                                        // find each of its needed secondary assignment operators
-                                        std::list< Expression* > &tyParams = refType->get_parameters();
-                                        std::list< TypeDecl* > &forallParams = functionDecl->get_type()->get_forall();
-                                        std::list< Expression* >::const_iterator tyIt = tyParams.begin();
-                                        std::list< TypeDecl* >::const_iterator forallIt = forallParams.begin();
-                                        for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) {
-                                                if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue; // skip types with no assign op (ftype/dtype)
-
-                                                std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
-                                                assert( ! asserts.empty() && "Type param needs assignment operator assertion" );
-                                                DeclarationWithType *actualDecl = asserts.front();
-                                                TypeInstType *actualType = isTypeInstAssignment( actualDecl );
-                                                assert( actualType && "First assertion of type with assertions should be assignment operator" );
-                                                TypeExpr *formalTypeExpr = dynamic_cast< TypeExpr* >( *tyIt );
-                                                assert( formalTypeExpr && "type parameters must be type expressions" );
-                                                Type *formalType = formalTypeExpr->get_type();
-                                                assignExpr->get_env()->add( actualType->get_name(), formalType );
-                                                
-                                                DeclarationWithType *assertAssign = 0;
-                                                if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) {
-                                                        std::map< std::string, DeclarationWithType *>::const_iterator assertAssignIt = assignOps.find( formalTypeInstType->get_name() );
-                                                        if ( assertAssignIt == assignOps.end() ) {
-                                                                throw SemanticError( "No assignment operation found for ", formalTypeInstType );
-                                                        }
-                                                        assertAssign = assertAssignIt->second;
-                                                } else {
-                                                        assertAssign = scopedAssignOps.find( formalType );
-                                                        if ( ! assertAssign ) {
-                                                                throw SemanticError( "No assignment operation found for ", formalType );
-                                                        }
-                                                }
-                                                
-
-                                                assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
-                                                        = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) );
-                                        }
+                                        DeclarationWithType *functionDecl = assignIter->second;
+                                        // line below cloned from FixFunction.cc
+                                        assignDecl = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0,
+                                                                     new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
+                                        assignDecl->set_mangleName( functionDecl->get_mangleName() );
                                 }
-                                assert( assignExpr );
+                                assert( assignDecl );
 
                                 // replace return statement with appropriate assignment to out parameter
+                                ApplicationExpr *assignExpr = new ApplicationExpr( new VariableExpr( assignDecl ) );
                                 Expression *retParm = new NameExpr( retval->get_name() );
                                 retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
@@ -1269 +1180 @@
                         }
 
-                        // add size/align for generic parameter types to parameter list
+                        // add size/align for generic types to parameter list
                         std::set< std::string > seenTypes; // sizeofName for generic types we've seen
                         for ( std::list< DeclarationWithType* >::const_iterator fnParm = last; fnParm != funcType->get_parameters().end(); ++fnParm ) {
@@ -1384 +1295 @@
 
                                 if ( DeclarationWithType *declWithType = dynamic_cast< DeclarationWithType* >( *decl ) ) {
-                                        if ( memberDecl->get_mangleName().empty() || declWithType->get_mangleName().empty()
-                                             || memberDecl->get_mangleName() == declWithType->get_mangleName() ) return i;
+                                        if ( memberDecl->get_mangleName() == declWithType->get_mangleName() ) return i;
                                         else continue;
                                 } else return i;
@@ -1431 +1341 @@
                         if ( ! objectType ) return memberExpr;
 
-                        Expression *newMemberExpr = 0;
                         if ( StructInstType *structType = dynamic_cast< StructInstType* >( objectType ) ) {
                                 // look up offset index
@@ -1441 +1350 @@
                                 fieldLoc->get_args().push_back( makeDerefdVar( varExpr->clone(), varDepth ) );
                                 fieldLoc->get_args().push_back( makeOffsetIndex( objectType, i ) );
-                                newMemberExpr = fieldLoc;
-                        } else if ( dynamic_cast< UnionInstType* >( objectType ) ) {
+
+                                delete memberExpr;
+                                return fieldLoc;
+                        } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType ) ) {
                                 // union members are all at offset zero, so build appropriately-dereferenced variable
-                                newMemberExpr = makeDerefdVar( varExpr->clone(), varDepth );
+                                Expression *derefdVar = makeDerefdVar( varExpr->clone(), varDepth );
+                                delete memberExpr;
+                                return derefdVar;
                         } else return memberExpr;
-                        assert( newMemberExpr );
-
-                        Type *memberType = memberExpr->get_member()->get_type();
-                        if ( ! isPolyType( memberType, scopeTyVars ) ) {
-                                // Not all members of a polymorphic type are themselves of polymorphic type; in this case the member expression should be wrapped and dereferenced to form an lvalue
-                                CastExpr *ptrCastExpr = new CastExpr( newMemberExpr, new PointerType( Type::Qualifiers(), memberType->clone() ) );
-                                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
-                                derefExpr->get_args().push_back( ptrCastExpr );
-                                newMemberExpr = derefExpr;
-                        }
-
-                        delete memberExpr;
-                        return newMemberExpr;
                 }
 
@@ -1479 +1379 @@
                                 delete offsetofExpr;
                                 return offsetInd;
-                        } else if ( dynamic_cast< UnionInstType* >( ty ) ) {
+                        } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( ty ) ) {
                                 // all union members are at offset zero
                                 delete offsetofExpr;

src/ResolvExpr/AlternativeFinder.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// AlternativeFinder.cc --
+// AlternativeFinder.cc -- 
 //
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:52:08 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed Feb 10 17:00:04 2016
-// Update Count     : 24
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Jul  3 17:58:39 2015
+// Update Count     : 22
 //
 
@@ -41 +41 @@
 
 extern bool resolvep;
-#define PRINT( text ) if ( resolvep ) { text }
+#define PRINT( text ) if ( resolvep ) { text } 
 //#define DEBUG_COST
 
@@ -107 +107 @@
                                         if ( candidate->cost < mapPlace->second.candidate->cost ) {
                                                 PRINT(
-                                                        std::cerr << "cost " << candidate->cost << " beats " << mapPlace->second.candidate->cost << std::endl;
+                                                        std::cout << "cost " << candidate->cost << " beats " << mapPlace->second.candidate->cost << std::endl;
                                                 )
                                                 selected[ mangleName ] = current;
                                         } else if ( candidate->cost == mapPlace->second.candidate->cost ) {
                                                 PRINT(
-                                                        std::cerr << "marking ambiguous" << std::endl;
+                                                        std::cout << "marking ambiguous" << std::endl;
                                                 )
                                                 mapPlace->second.isAmbiguous = true;
@@ -122 +122 @@
 
                         PRINT(
-                                std::cerr << "there are " << selected.size() << " alternatives before elimination" << std::endl;
+                                std::cout << "there are " << selected.size() << " alternatives before elimination" << std::endl;
                         )
 
@@ -182 +182 @@
                         begin++;
                         PRINT(
-                                std::cerr << "findSubExprs" << std::endl;
-                                printAlts( finder.alternatives, std::cerr );
+                                std::cout << "findSubExprs" << std::endl;
+                                printAlts( finder.alternatives, std::cout );
                         )
                         *out++ = finder;
@@ -204 +204 @@
                 }
                 PRINT(
-                        std::cerr << "alternatives before prune:" << std::endl;
-                        printAlts( alternatives, std::cerr );
+                        std::cout << "alternatives before prune:" << std::endl;
+                        printAlts( alternatives, std::cout );
                 )
                 AltList::iterator oldBegin = alternatives.begin();
@@ -221 +221 @@
                 alternatives.erase( oldBegin, alternatives.end() );
                 PRINT(
-                        std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
+                        std::cout << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
                 )
         }
@@ -261 +261 @@
                 for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
                         PRINT(
-                                std::cerr << "actual expression:" << std::endl;
-                                (*actualExpr)->print( std::cerr, 8 );
-                                std::cerr << "--- results are" << std::endl;
-                                printAll( (*actualExpr)->get_results(), std::cerr, 8 );
+                                std::cout << "actual expression:" << std::endl;
+                                (*actualExpr)->print( std::cout, 8 );
+                                std::cout << "--- results are" << std::endl;
+                                printAll( (*actualExpr)->get_results(), std::cout, 8 );
                         )
                         std::list< DeclarationWithType* >::iterator startFormal = formal;
@@ -278 +278 @@
                                 }
                                 PRINT(
-                                        std::cerr << std::endl << "converting ";
-                                        (*actual)->print( std::cerr, 8 );
-                                        std::cerr << std::endl << " to ";
-                                        (*formal)->get_type()->print( std::cerr, 8 );
+                                        std::cout << std::endl << "converting ";
+                                        (*actual)->print( std::cout, 8 );
+                                        std::cout << std::endl << " to ";
+                                        (*formal)->get_type()->print( std::cout, 8 );
                                 )
                                 Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
                                 PRINT(
-                                        std::cerr << std::endl << "cost is" << newCost << std::endl;
+                                        std::cout << std::endl << "cost is" << newCost << std::endl;
                                 )
 
@@ -323 +323 @@
                 for ( InferredParams::const_iterator assert = appExpr->get_inferParams().begin(); assert != appExpr->get_inferParams().end(); ++assert ) {
                         PRINT(
-                                std::cerr << std::endl << "converting ";
-                                assert->second.actualType->print( std::cerr, 8 );
-                                std::cerr << std::endl << " to ";
-                                assert->second.formalType->print( std::cerr, 8 );
+                                std::cout << std::endl << "converting ";
+                                assert->second.actualType->print( std::cout, 8 );
+                                std::cout << std::endl << " to ";
+                                assert->second.formalType->print( std::cout, 8 );
                                 )
                                 Cost newCost = conversionCost( assert->second.actualType, assert->second.formalType, indexer, alt.env );
                         PRINT(
-                                std::cerr << std::endl << "cost of conversion is " << newCost << std::endl;
+                                std::cout << std::endl << "cost of conversion is " << newCost << std::endl;
                                 )
                                 if ( newCost == Cost::infinity ) {
@@ -448 +448 @@
                 std::list< DeclarationWithType* > candidates;
                 decls.lookupId( curDecl->get_name(), candidates );
-///   if ( candidates.empty() ) { std::cerr << "no candidates!" << std::endl; }
+///   if ( candidates.empty() ) { std::cout << "no candidates!" << std::endl; }
                 for ( std::list< DeclarationWithType* >::const_iterator candidate = candidates.begin(); candidate != candidates.end(); ++candidate ) {
                         PRINT(
-                                std::cerr << "inferRecursive: candidate is ";
-                                (*candidate)->print( std::cerr );
-                                std::cerr << std::endl;
+                                std::cout << "inferRecursive: candidate is ";
+                                (*candidate)->print( std::cout );
+                                std::cout << std::endl;
                         )
                         AssertionSet newHave, newerNeed( newNeed );
@@ -482 +482 @@
                                 varExpr->get_results().push_front( adjType->clone() );
                                 PRINT(
-                                        std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
-                                        curDecl->print( std::cerr );
-                                        std::cerr << " with declaration " << (*candidate)->get_uniqueId() << " ";
-                                        (*candidate)->print( std::cerr );
-                                        std::cerr << std::endl;
+                                        std::cout << "satisfying assertion " << curDecl->get_uniqueId() << " ";
+                                        curDecl->print( std::cout );
+                                        std::cout << " with declaration " << (*candidate)->get_uniqueId() << " ";
+                                        (*candidate)->print( std::cout );
+                                        std::cout << std::endl;
                                 )
                                 ApplicationExpr *appExpr = static_cast< ApplicationExpr* >( newerAlt.expr );
@@ -501 +501 @@
         void AlternativeFinder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) {
 //      PRINT(
-//          std::cerr << "inferParameters: assertions needed are" << std::endl;
-//          printAll( need, std::cerr, 8 );
+//          std::cout << "inferParameters: assertions needed are" << std::endl;
+//          printAll( need, std::cout, 8 );
 //          )
                 SymTab::Indexer decls( indexer );
                 PRINT(
-                        std::cerr << "============= original indexer" << std::endl;
-                        indexer.print( std::cerr );
-                        std::cerr << "============= new indexer" << std::endl;
-                        decls.print( std::cerr );
+                        std::cout << "============= original indexer" << std::endl;
+                        indexer.print( std::cout );
+                        std::cout << "============= new indexer" << std::endl;
+                        decls.print( std::cout );
                 )
                 addToIndexer( have, decls );
@@ -515 +515 @@
                 inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
 //      PRINT(
-//          std::cerr << "declaration 14 is ";
+//          std::cout << "declaration 14 is ";
 //          Declaration::declFromId
 //          *out++ = newAlt;
@@ -532 +532 @@
                         makeExprList( actualAlt, appExpr->get_args() );
                         PRINT(
-                                std::cerr << "need assertions:" << std::endl;
-                                printAssertionSet( resultNeed, std::cerr, 8 );
+                                std::cout << "need assertions:" << std::endl;
+                                printAssertionSet( resultNeed, std::cout, 8 );
                         )
                         inferParameters( resultNeed, resultHave, newAlt, openVars, out );
@@ -543 +543 @@
                 AlternativeFinder funcOpFinder( indexer, env );
 
-                AlternativeFinder funcFinder( indexer, env );
-
-                {
+                AlternativeFinder funcFinder( indexer, env ); {
                         NameExpr *fname = 0;;
                         if ( ( fname = dynamic_cast<NameExpr *>( untypedExpr->get_function()))
@@ -575 +573 @@
                 for ( AltList::const_iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
                         PRINT(
-                                std::cerr << "working on alternative: " << std::endl;
-                                func->print( std::cerr, 8 );
+                                std::cout << "working on alternative: " << std::endl;
+                                func->print( std::cout, 8 );
                         )
                         // check if the type is pointer to function
@@ -608 +606 @@
                                         }
                                         PRINT(
-                                                std::cerr << "known function ops:" << std::endl;
-                                                printAlts( funcOpFinder.alternatives, std::cerr, 8 );
+                                                std::cout << "known function ops:" << std::endl;
+                                                printAlts( funcOpFinder.alternatives, std::cout, 8 );
                                         )
                                 }
@@ -641 +639 @@
                                 FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
                                 assert( function );
-                                std::cerr << "Case +++++++++++++" << std::endl;
-                                std::cerr << "formals are:" << std::endl;
-                                printAll( function->get_parameters(), std::cerr, 8 );
-                                std::cerr << "actuals are:" << std::endl;
-                                printAll( appExpr->get_args(), std::cerr, 8 );
-                                std::cerr << "bindings are:" << std::endl;
-                                withFunc->env.print( std::cerr, 8 );
-                                std::cerr << "cost of conversion is:" << cvtCost << std::endl;
+                                std::cout << "Case +++++++++++++" << std::endl;
+                                std::cout << "formals are:" << std::endl;
+                                printAll( function->get_parameters(), std::cout, 8 );
+                                std::cout << "actuals are:" << std::endl;
+                                printAll( appExpr->get_args(), std::cout, 8 );
+                                std::cout << "bindings are:" << std::endl;
+                                withFunc->env.print( std::cout, 8 );
+                                std::cout << "cost of conversion is:" << cvtCost << std::endl;
                         )
                         if ( cvtCost != Cost::infinity ) {
@@ -826 +824 @@
                 }
         }
-
+        
         void AlternativeFinder::visit( UntypedOffsetofExpr *offsetofExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
@@ -835 +833 @@
                 }
         }
-
+        
         void AlternativeFinder::visit( OffsetofExpr *offsetofExpr ) {
                 alternatives.push_back( Alternative( offsetofExpr->clone(), env, Cost::zero ) );
@@ -845 +843 @@
                 assert( function->get_parameters().size() == 1 );
                 PRINT(
-                        std::cerr << "resolvAttr: funcDecl is ";
-                        funcDecl->print( std::cerr );
-                        std::cerr << " argType is ";
-                        argType->print( std::cerr );
-                        std::cerr << std::endl;
+                        std::cout << "resolvAttr: funcDecl is ";
+                        funcDecl->print( std::cout );
+                        std::cout << " argType is ";
+                        argType->print( std::cout );
+                        std::cout << std::endl;
                 )
                 if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {

src/ResolvExpr/CastCost.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 06:57:43 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  2 15:34:36 2016
-// Update Count     : 7
+// Last Modified By : Rob Schluntz
+// Last Modified On : Mon Oct 05 14:48:45 2015
+// Update Count     : 5
 //
 
@@ -69 +69 @@
                 PointerType *destAsPointer = dynamic_cast< PointerType* >( dest );
                 if ( destAsPointer && basicType->isInteger() ) {
-                        //cost = Cost( 1, 0, 0 );
-                        cost = Cost::infinity;
+                        cost = Cost( 1, 0, 0 );
                 } else {
                         ConversionCost::visit( basicType );
@@ -88 +87 @@
                                         cost = Cost( 0, 0, 1 );
                                 } else if ( castResult < 0 ) {
-                                        cost = Cost::infinity;
-                                        //cost = Cost( 1, 0, 0 );
+                                        cost = Cost( 1, 0, 0 );
                                 } // if
                         } // if
                 } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
                         if ( destAsBasic->isInteger() ) {
-                                //cost = Cost( 1, 0, 0 );
-                                cost = Cost::infinity;
+                                cost = Cost( 1, 0, 0 );
                         } // if
                 }

src/ResolvExpr/Resolver.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 12:17:01 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  9 21:57:52 2016
-// Update Count     : 179
+// Last Modified On : Fri Jul 24 17:33:54 2015
+// Update Count     : 178
 //
 
@@ -322 +322 @@
                                                                                                 BasicType::SignedInt);
                                 } else {
-                                        DeclarationWithType * decl = lookupId( n );
+                                        DeclarationWithType * decl = lookupId(n);
                                         initContext = decl->get_type();
                                 }
@@ -344 +344 @@
                                         if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_results().front() ) ) {
                                                 if ( isCharType( pt->get_base() ) ) {
-                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                        // strip cast if we're initializing a char[] with a char *, e.g.
+                                                        // char x[] = "hello";
                                                         CastExpr *ce = dynamic_cast< CastExpr * >( newExpr );
                                                         singleInit->set_value( ce->get_arg() );

src/SymTab/Validate.cc

@@ -382 +382 @@
                 // it's not a semantic error if the struct is not found, just an implicit forward declaration
                 if ( st ) {
-                        //assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
+                        assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
                         structInst->set_baseStruct( st );
                 } // if
@@ -659 +659 @@
         }
 
-        /// Creates a new type decl that's the same as src, but renamed and with only the ?=? assertion (for complete types only)
-        TypeDecl *cloneAndRename( TypeDecl *src, const std::string &name ) {
-                TypeDecl *dst = new TypeDecl( name, src->get_storageClass(), 0, src->get_kind() );
-
-                if ( src->get_kind() == TypeDecl::Any ) {
-                        // just include assignment operator assertion
-                        TypeInstType *assignParamType = new TypeInstType( Type::Qualifiers(), name, dst );
-                        FunctionType *assignFunctionType = new FunctionType( Type::Qualifiers(), false );
-                        assignFunctionType->get_returnVals().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType->clone(), 0 ) );
-                        assignFunctionType->get_parameters().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), assignParamType->clone() ), 0 ) );
-                        assignFunctionType->get_parameters().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType, 0 ) );
-                        FunctionDecl *assignAssert = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignFunctionType, 0, false, false );
-                        dst->get_assertions().push_back( assignAssert );
-                }
-
-                return dst;
-        }
-
         Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
                 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
@@ -687 +666 @@
                 std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters();
                 std::list< Expression* > structParams;  // List of matching parameters to put on types
-                TypeSubstitution genericSubs; // Substitutions to make to member types of struct
                 for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
                         isGeneric = true;
-                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
+                        TypeDecl *typeParam = (*param)->clone();
                         assignType->get_forall().push_back( typeParam );
-                        TypeInstType *newParamType = new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam );
-                        genericSubs.add( (*param)->get_name(), newParamType );
-                        structParams.push_back( new TypeExpr( newParamType ) );
+                        structParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );
                 }
 
@@ -725 +701 @@
                                 }
 
-                                if ( isGeneric ) {
-                                        // rewrite member type in terms of the type variables on this operator
-                                        DeclarationWithType *fixedMember = dwt->clone();
-                                        genericSubs.apply( fixedMember );
-
-                                        // assign to both destination and return value
-                                        if ( ArrayType *array = dynamic_cast< ArrayType * >( fixedMember->get_type() ) ) {
-                                                makeArrayAssignment( srcParam, dstParam, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                                makeArrayAssignment( srcParam, returnVal, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } else {
-                                                makeScalarAssignment( srcParam, dstParam, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                                makeScalarAssignment( srcParam, returnVal, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } // if
+                                if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
+                                        makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                        if ( isGeneric ) makeArrayAssignment( srcParam, returnVal, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
                                 } else {
-                                        // assign to destination
-                                        if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
-                                                makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } else {
-                                                makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } // if
+                                        makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                        if ( isGeneric ) makeScalarAssignment( srcParam, returnVal, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
                                 } // if
                         } // if
@@ -762 +724 @@
                 for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
                         isGeneric = true;
-                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
+                        TypeDecl *typeParam = (*param)->clone();
                         assignType->get_forall().push_back( typeParam );
                         unionParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );

src/Tests/Makefile

@@ -8 +8 @@
 OUTPUTS = ${addprefix ${OUTPUTDIR}/,${EXAMPLES:.c=.txt}}
 
-#.SILENT :
+.SILENT :
 
 all :
@@ -19 +19 @@
 
 ${OUTPUTDIR}/%.txt : %.c ${CFA} Makefile
-        -${CFA} -n ${CFAOPT} $< > $@ 2>&1
+        -${CFA} -n ${CFAOPT} < $< > $@ 2>&1
 
 ${OUTPUTDIR}/report : ${OUTPUTS} ${EXPECTDIR}

src/examples/abs.c

@@ -10 +10 @@
 // Created On       : Thu Jan 28 18:26:16 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 09:32:04 2016
-// Update Count     : 44
+// Last Modified On : Wed Feb  3 11:14:58 2016
+// Update Count     : 43
 //
 
@@ -18 +18 @@
 
 int main( void ) {
+        ofstream *sout = ofstream_stdout();
+
         char ch = -65;
         sout | "char\t\t\t"                                     | ch     | "\tabs " | abs( ch ) | endl;

src/examples/alloc.c

@@ -11 +11 @@
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 11:43:23 2016
-// Update Count     : 40
+// Last Modified On : Wed Feb  3 16:32:04 2016
+// Update Count     : 38
 // 
 
@@ -27 +27 @@
 
 int main( void ) {
+    ofstream * sout = ofstream_stdout();
+
     size_t size = 10;
     int * p;
@@ -98 +100 @@
     free( x );
 #endif
+    free( sout );
 }
 

src/examples/fstream_test.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 11:45:43 2016
-// Update Count     : 43
+// Last Modified On : Tue Jan 26 17:11:33 2016
+// Update Count     : 42
 //
 
@@ -17 +17 @@
 
 int main( void ) {
+        ofstream *sout = ofstream_stdout();
+        ifstream *sin = ifstream_stdin();
         int nombre;
         sout | "Entrez un nombre, s'il vous plaît:\n";

src/examples/hello.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 12:11:45 2016
-// Update Count     : 8
+// Last Modified On : Tue Jan 26 17:11:49 2016
+// Update Count     : 7
 //
 
@@ -17 +17 @@
 
 int main() {
+        ofstream *sout = ofstream_stdout();
+        ifstream *sin = ifstream_stdin();
         sout | "Bonjour au monde!\n";
 }

src/examples/identity.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 12:17:32 2016
-// Update Count     : 10
+// Last Modified On : Tue Jan 26 17:11:58 2016
+// Update Count     : 8
 //
 
@@ -22 +22 @@
 
 int main() {
+        ofstream *sout = ofstream_stdout();
         sout | "char\t\t\t"                                     | identity( 'z' ) | endl;
         sout | "signed int\t\t"                         | identity( 4 ) | endl;
@@ -29 +30 @@
         sout | "signed long long int\t"         | identity( 4ll ) | endl;
         sout | "unsigned long long int\t"       | identity( 4ull ) | endl;
-        sout | "float\t\t\t"                            | identity( 4.1f ) | endl;
-        sout | "double\t\t\t"                           | identity( 4.1 ) | endl;
-        sout | "long double\t\t"                        | identity( 4.1l ) | endl;
+        sout | "float\t\t\t"                            | identity( 4.0f ) | endl;
+        sout | "double\t\t\t"                           | identity( 4.0 ) | endl;
+        sout | "long double\t\t"                        | identity( 4.0l ) | endl;
 }
 

src/examples/minmax.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 12:17:53 2016
-// Update Count     : 47
+// Last Modified On : Wed Feb  3 11:14:49 2016
+// Update Count     : 46
 //
 
@@ -18 +18 @@
 
 int main( void ) {
+        ofstream *sout = ofstream_stdout();
         // char does not have less or greater than.
         int ?<?( char op1, char op2 ) { return (int)op1 < (int)op2; }

src/examples/quad.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 12:19:24 2016
-// Update Count     : 6
+// Last Modified On : Tue Jan 26 17:13:48 2016
+// Update Count     : 5
 //
 
@@ -27 +27 @@
 
 int main() {
+        ofstream *sout = ofstream_stdout();
         int N = 2;
         sout | "result of quad of " | N | " is " | quad( N ) | endl;

src/examples/quoted_keyword.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 12:19:45 2016
-// Update Count     : 9
+// Last Modified On : Tue Jan 26 17:13:58 2016
+// Update Count     : 8
 //
 
@@ -28 +28 @@
 
 int main() {
+        ofstream *sout = ofstream_stdout();
         sout | `catch` + st.`type` + st.`struct` + `throw` | endl;
 }

src/examples/random.c

@@ -7 +7 @@
 
 int main() {
+        ofstream *sout = ofstream_stdout();
+
         randseed( getpid() );                                                           // set random seed
 

src/examples/square.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 12:21:58 2016
-// Update Count     : 26
+// Last Modified On : Tue Jan 26 17:14:16 2016
+// Update Count     : 25
 //
 
@@ -23 +23 @@
 int main() {
 #if 0
+        ofstream *sout = ofstream_stdout();
         sout | "result of squaring 9 is " | endl;
 

src/examples/sum.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb 16 23:49:31 2016
-// Update Count     : 189
+// Last Modified On : Fri Feb  5 16:47:44 2016
+// Update Count     : 139
 //
 
@@ -33 +33 @@
 
 // Required to satisfy sumable as char does not have addition.
-const char 0;
-char ?+?( char t1, char t2 ) { return (int)t1 + t2; }   // cast forces integer addition, otherwise recursion
-char ?+=?( char *t1, char t2 ) { *t1 = *t1 + t2; return *t1; }
-char ++?( char *t ) { *t += 1; return *t; }
-char ?++( char *t ) { char temp = *t; *t += 1; return temp; }
+// const char 0;
+// char ?+?( char op1, char op2 ) { return (int)op1 + op2; } // cast forces integer addition or recursion
+// char ++?( char *op ) { *op += 1; return *op; }
+// char ?++( char *op ) { char temp = *op; *op += 1; return temp; }
 
 int main( void ) {
         const int low = 5, High = 15, size = High - low;
+        ofstream *sout = ofstream_stdout();
+#if 0
 
-        char s = 0, a[size], v = low;
+        char s = 0, a[size];
+        char v = low;
         for ( int i = 0; i < size; i += 1, v += 1 ) {
                 s += v;
                 a[i] = v;
-        } // for
+        }
         sout | "sum from " | low | " to " | High | " is "
                  | (int)sum( size, a ) | ", check " | (int)s | endl;
 
-        int s = 0, a[size], v = low;
+        int s = 0, a[size];
+        int v = low;
         for ( int i = 0; i < size; i += 1, v += 1 ) {
                 s += (int)v;
                 a[i] = (int)v;
-        } // for
+        }
         sout | "sum from " | low | " to " | High | " is "
                  | sum( size, (int *)a ) | ", check " | (int)s | endl;
 
-        float s = 0.0, a[size], v = low / 10.0;
+        float s = 0.0, a[size];
+        float v = low / 10.0;
         for ( int i = 0; i < size; i += 1, v += 0.1f ) {
                 s += (float)v;
                 a[i] = (float)v;
-        } // for
+        }
         sout | "sum from " | low / 10.0 | " to " | High / 10.0 | " is "
                  | sum( size, (float *)a ) | ", check " | (float)s | endl;
+#endif
+        double s = 0, a[size];
+        double v = low / 10.0;
 
-        double s = 0, a[size], v = low / 10.0;
         for ( int i = 0; i < size; i += 1, v += 0.1 ) {
                 s += (double)v;
                 a[i] = (double)v;
-        } // for
+        }
         sout | "sum from " | low / 10.0 | " to " | High / 10.0 | " is "
                  | sum( size, (double *)a ) | ", check " | (double)s | endl;
 
-        struct S { int i, j; } 0 = { 0, 0 }, 1 = { 1, 1 };
-        S ?+?( S t1, S t2 ) { S s = { t1.i + t2.i, t1.j + t2.j }; return s; }
-        S ?+=?( S *t1, S t2 ) { *t1 = *t1 + t2; return *t1; }
-        S ++?( S *t ) { *t += 1; return *t; }
-        S ?++( S *t ) { S temp = *t; *t += 1; return temp; }
-        ofstream * ?|?( ofstream * os, S v ) { return os | v.i | ' ' | v.j; }
-
-        S s = 0, a[size], v = { low, low };
-        for ( int i = 0; i < size; i += 1, v += (S)1 ) {
-                s += (S)v;
-                a[i] = (S)v;
-        } // for
-        sout | "sum from " | low | " to " | High | " is "
-                 | sum( size, (S *)a ) | ", check " | (S)s | endl;
+        // struct S { int i, j; } sarr[size];
+        // struct S 0 = { 0, 0 };
+        // struct S 1 = { 1, 1 };
+        // S ?+?( S t1, S t2 ) { S s = { t1.i + t1.j, t2.i + t2.j }; return s; }
+        // S ?+=?( S *t1, S t2 ) { *t1 = *t1 + t2; return *t1; }
+        // S ++?( S *t ) { *t += 1; return *t; }
+        // S ?++( S *t ) { S temp = *t; *t += 1; return temp; }
+        // sum( size, sarr );
 } // main
 

src/examples/swap.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 12:22:12 2016
-// Update Count     : 64
+// Last Modified On : Wed Feb  3 11:14:04 2016
+// Update Count     : 63
 //
 
@@ -18 +18 @@
 
 int main( void ) {
+        ofstream *sout = ofstream_stdout();
+
         char c1 = 'a', c2 = 'b';
         sout | "char\t\t\t" | c1 | ' ' | c2 | "\t\t\tswap ";

src/examples/twice.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 12:23:25 2016
-// Update Count     : 13
+// Last Modified On : Tue Jan 26 17:14:44 2016
+// Update Count     : 12
 //
 
@@ -27 +27 @@
         char ?++( char *op ) { char temp = *op; *op += 1; return temp; }
 
+        ofstream *sout = ofstream_stdout();
         sout | twice( 'a' ) | ' ' | twice( 1 ) | ' ' | twice( 3.2 ) | endl;
 }

src/examples/vector_test.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 12:23:55 2016
-// Update Count     : 18
+// Last Modified On : Tue Jan 26 17:14:52 2016
+// Update Count     : 17
 //
 
@@ -20 +20 @@
 
 int main( void ) {
+        ofstream *sout = ofstream_stdout();
+        ifstream *sin = ifstream_stdin();
         vector_int vec = vector_int_allocate();
 

src/libcfa/fstream

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 14:02:01 2016
-// Update Count     : 22
+// Last Modified On : Wed Jan 27 23:47:41 2016
+// Update Count     : 3
 //
 
@@ -19 +19 @@
 #include "iostream"
 
+typedef struct ofstream ofstream;
+
 // implement context ostream
-struct ofstream;
+ofstream *write( ofstream *, const char *, streamsize_type );
+int fail( ofstream * );
 
-int fail( ofstream * os );
-int flush( ofstream * os );
-void open( ofstream ** os, const char * name, const char * mode );
-void close( ofstream * os );
-ofstream * write( ofstream * os, const char * data, streamsize_type size );
+ofstream *ofstream_stdout();
+ofstream *ofstream_stderr();
+ofstream *ofstream_fromfile( const char *name );
+void ofstream_close( ofstream *os );
 
-extern ofstream * sout, * serr;
+typedef struct ifstream ifstream;
 
 // implement context istream
-struct ifstream;
+ifstream *read( ifstream *, char *, streamsize_type );
+ifstream *unread( ifstream *, char );
+int fail( ifstream * );
+int eof( ifstream * );
 
-int fail( ifstream * is );
-int eof( ifstream * is );
-void open( ifstream ** is, const char * name, const char * mode );
-void close( ifstream * is );
-ifstream * get( ifstream * is, int * data );
-ifstream * read( ifstream * is, char * data, streamsize_type size );
-ifstream * ungetc( ifstream * is, char c );
-
-extern ifstream *sin;
+ifstream *ifstream_stdin();
+ifstream *ifstream_fromfile( const char *name );
 
 #endif // __FSTREAM_H__

src/libcfa/fstream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 14:03:05 2016
-// Update Count     : 76
+// Last Modified On : Tue Jan 26 17:12:59 2016
+// Update Count     : 6
 //
 
@@ -23 +23 @@
 struct ofstream {
         FILE *file;
+        int fail;
 };
 
-#define IO_MSG "I/O error "
-
-int fail( ofstream * os ) {
-        return ferror( os->file );
-} // fail
-
-int flush( ofstream * os ) {
-        return fflush( os->file );
-} // flush
-
-void open( ofstream ** os, const char * name, const char * mode ) {
-        FILE *t = fopen( name, mode );
-        if ( t == 0 ) {                                                                         // do not change unless successful
-                perror( IO_MSG "open output" );
-                exit( EXIT_FAILURE );
-        } // if
-        (*os)->file = t;
-} // open
-
-void close( ofstream * os ) {
-        if ( os->file == stdout || os->file == stderr ) return;
-
-        if ( fclose( os->file ) == EOF ) {
-                perror( IO_MSG "close output" );
-        } // if 
-} // close
-
-ofstream * write( ofstream * os, const char * data, streamsize_type size ) {
-        if ( fail( os ) ) {
-                fprintf( stderr, "attempt write I/O on failed stream\n" );
-                exit( EXIT_FAILURE );
-        } // if
-
-        if ( fwrite( data, 1, size, os->file ) != size ) {
-                perror( IO_MSG "write" );
-                exit( EXIT_FAILURE );
+ofstream *write( ofstream *os, const char *data, streamsize_type size ) {
+        if ( ! os->fail ) {
+                fwrite( data, size, 1, os->file );
+                os->fail = ferror( os->file );
         } // if
         return os;
 } // write
 
-static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_) };
-ofstream *sout = &soutFile;
-static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_) };
-ofstream *serr = &serrFile;
+int fail( ofstream *os ) {
+        return os->fail;
+} // fail
 
-//---------------------------------------
+static ofstream *make_ofstream() {
+        ofstream *new_stream = malloc( sizeof( ofstream ) );
+        new_stream->fail = 0;
+        return new_stream;
+} // make_ofstream
+
+ofstream *ofstream_stdout() {
+        ofstream *stdout_stream = make_ofstream();
+        stdout_stream->file = stdout;
+        return stdout_stream;
+} // ofstream_stdout
+
+ofstream *ofstream_stderr() {
+        ofstream *stderr_stream = make_ofstream();
+        stderr_stream->file = stderr;
+        return stderr_stream;
+} // ofstream_stderr
+
+ofstream *ofstream_fromfile( const char *name ) {
+        ofstream *file_stream = make_ofstream();
+        file_stream->file = fopen( name, "w" );
+        file_stream->fail = file_stream->file == 0;
+        return file_stream;
+}
+
+void ofstream_close( ofstream *os ) {
+        if ( os->file != stdout && os->file != stderr ) {
+                os->fail = fclose( os->file );
+        }
+        free( os );
+}
 
 struct ifstream {
         FILE *file;
+        int fail;
+        int eof;
 };
 
-int fail( ifstream * is ) {
-        return ferror( is->file );
-} // fail
+ifstream *read( ifstream *is, char *data, streamsize_type size ) {
+        if ( ! is->fail && ! is->eof ) {
+                fread( data, size, 1, is->file );
+                is->fail = ferror( is->file );
+                is->eof = feof( is->file );
+        }
+        return is;
+}
+  
+ifstream *unread( ifstream *is, char c ) {
+        if ( ! is->fail ) {
+                if ( ! EOF == ungetc( c, is->file ) ) {
+                        is->fail = 1;
+                }
+        }
+        return is;
+}
 
-int eof( ifstream * is ) {
-        return feof( is->file );
-} // eof
+int fail( ifstream *is ) {
+        return is->fail;
+}
 
-ifstream * get( ifstream * is, int * data ) {
-        if ( fscanf( is->file, "%d", data ) == EOF ) {
-                if ( ferror( is->file ) ) {
-                        fprintf( stderr, "invalid int read\n" );
-                        exit( EXIT_FAILURE );
-                } // if
-        } // if
-        return is;
-} // read
+int eof( ifstream *is ) {
+        return is->eof;
+}
 
-ifstream * read( ifstream * is, char * data, streamsize_type size ) {
-        if ( fail( is ) ) {
-                fprintf( stderr, "attempt read I/O on failed stream\n" );
-                exit( EXIT_FAILURE );
-        } // if
+static ifstream *make_ifstream() {
+        ifstream *new_stream = malloc( sizeof( ifstream ) );
+        new_stream->fail = 0;
+        new_stream->eof = 0;
+        return new_stream;
+}
 
-        if ( fread( data, size, 1, is->file ) == 0 ) {
-                perror( IO_MSG "read" );
-                exit( EXIT_FAILURE );
-        } // if
-        return is;
-} // read
-  
-ifstream *ungetc( ifstream * is, char c ) {
-        if ( fail( is ) ) {
-                fprintf( stderr, "attempt ungetc I/O on failed stream\n" );
-                exit( EXIT_FAILURE );
-        } // if
+ifstream *ifstream_stdin() {
+        ifstream *stdin_stream = make_ifstream();
+        stdin_stream->file = stdin;
+        return stdin_stream;
+}
 
-        if ( ungetc( c, is->file ) == EOF ) {
-                perror( IO_MSG "ungetc" );
-                exit( EXIT_FAILURE );
-        } // if
-        return is;
-} // ungetc
-
-void open( ifstream ** is, const char * name, const char * mode ) {
-        FILE *t = fopen( name, mode );
-        if ( t == 0 ) {                                                                         // do not change unless successful
-                perror( IO_MSG "open input" );
-                exit( EXIT_FAILURE );
-        } // if
-        (*is)->file = t;
-} // open
-
-void close( ifstream * is ) {
-        if ( is->file == stdin ) return;
-
-        if ( fclose( is->file ) == EOF ) {
-                perror( IO_MSG "close input" );
-        } // if 
-} // close
-
-static ifstream sinFile = { (FILE *)(&_IO_2_1_stdin_) };
-ifstream *sin = &sinFile;
+ifstream *ifstream_fromfile( const char *name ) {
+        ifstream *file_stream = make_ifstream();
+        file_stream->file = fopen( name, "r" );
+        file_stream->fail = file_stream->file == 0;
+        return file_stream;
+}
 
 // Local Variables: //

src/libcfa/iostream

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 14:04:24 2016
-// Update Count     : 32
+// Last Modified On : Fri Jan 29 15:50:36 2016
+// Update Count     : 29
 //
 
@@ -22 +22 @@
 
 context ostream( dtype ostype ) {
+        ostype *write( ostype *, const char *, streamsize_type );
         int fail( ostype * );
-        int flush( ostype * );
-        ostype * write( ostype *, const char *, streamsize_type );
 };
+
 context writeable( type T ) {
         forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
@@ -52 +52 @@
 
 // writes the range [begin, end) to the given stream
-forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
+forall( type elt_type | writeable( elt_type ),
+                type iterator_type | iterator( iterator_type, elt_type ),
+                dtype os_type | ostream( os_type ) )
 void write( iterator_type begin, iterator_type end, os_type *os );
 
-forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
+forall( type elt_type | writeable( elt_type ),
+                type iterator_type | iterator( iterator_type, elt_type ),
+                dtype os_type | ostream( os_type ) )
 void write_reverse( iterator_type begin, iterator_type end, os_type *os );
 
-//---------------------------------------
+//******************************************************************************
 
 context istream( dtype istype ) {
+        istype *read( istype *, char *, streamsize_type );
+        istype *unread( istype *, char );
         int fail( istype * );
         int eof( istype * );
-        istype * get( istype *, int * );
-        istype * read( istype *, char *, streamsize_type );
-        istype * ungetc( istype *, char );
 };
 

src/libcfa/iostream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 14:19:56 2016
-// Update Count     : 76
+// Last Modified On : Mon Feb  1 14:20:30 2016
+// Update Count     : 60
 //
 
@@ -19 +19 @@
 #include <stdio.h>
 #include <string.h>                                                                             // strlen
-#include <float.h>                                                                              // DBL_DIG, LDBL_DIG
 #include <complex.h>                                                                    // creal, cimag
 }
@@ -73 +72 @@
 ostype * ?|?( ostype *os, double d ) {
         char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%.*lg", DBL_DIG, d ) );
+        return write( os, buffer, sprintf( buffer, "%g", d ) );
 } // ?|?
 
@@ -79 +78 @@
 ostype * ?|?( ostype *os, long double d ) {
         char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%.*Lg", LDBL_DIG, d ) );
+        return write( os, buffer, sprintf( buffer, "%Lg", d ) );
 } // ?|?
 
@@ -111 +110 @@
 forall( dtype ostype, dtype retostype | ostream( ostype ) | ostream( retostype ) ) 
 retostype * ?|?( ostype *os, retostype * (*manip)(ostype*) ) {
-  return manip( os );
+  return manip(os);
 }
 
 forall( dtype ostype | ostream( ostype ) ) 
 ostype * endl( ostype * os ) {
-        os | "\n";
-        flush( os );
-        return os;
+  os | "\n";
+  // flush
+  return os;
 } // endl
 
-//---------------------------------------
-
-forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ),
+forall( type elt_type | writeable( elt_type ),
+                type iterator_type | iterator( iterator_type, elt_type ),
                 dtype os_type | ostream( os_type ) )
 void write( iterator_type begin, iterator_type end, os_type *os ) {
-        void print( elt_type i ) { os | i | ' '; }
+        void print( elt_type i ) {
+                os | i | ' ';
+        }
         for_each( begin, end, print );
 } // ?|?
 
-forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ),
+forall( type elt_type | writeable( elt_type ),
+                type iterator_type | iterator( iterator_type, elt_type ),
                 dtype os_type | ostream( os_type ) )
 void write_reverse( iterator_type begin, iterator_type end, os_type *os ) {
@@ -137 +138 @@
 } // ?|?
 
-//---------------------------------------
 
 forall( dtype istype | istream( istype ) )
@@ -146 +146 @@
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype *is, int *ip ) {
-        return get( is, ip );
+        char cur;
+  
+        // skip some whitespace
+        do {
+                is | &cur;
+                if ( fail( is ) || eof( is ) ) return is;
+        } while ( !( cur >= '0' && cur <= '9' ) );
+  
+        // accumulate digits
+        *ip = 0;
+        while ( cur >= '0' && cur <= '9' ) {
+                *ip = *ip * 10 + ( cur - '0' );
+                is | &cur;
+                if ( fail( is ) || eof( is ) ) return is;
+        }
+  
+        unread( is, cur );
+        return is;
 } // ?|?
 

src/libcfa/stdlib.c

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 10 15:45:56 2016
-// Update Count     : 140
+// Last Modified On : Fri Feb  5 15:41:24 2016
+// Update Count     : 128
 //
 
@@ -23 +23 @@
 #include <string.h>                                                                             // memset
 #include <malloc.h>                                                                             // malloc_usable_size
+#include <stdio.h>
 #include <math.h>                                                                               // fabsf, fabs, fabsl
 #include <complex.h>                                                                    // _Complex_I, cabsf, cabs, cabsl
@@ -105 +106 @@
 long int ato( const char * ptr ) {
         long int li;
-        if ( sscanf( ptr, "%ld", &li ) == EOF ) {}                      // check return code
+        if ( sscanf( ptr, "%ld", &li ) == EOF ) {};                     // check return code
         return li;
 }
 unsigned long int ato( const char * ptr ) {
         unsigned long int uli;
-        if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}                     // check return code
+        if ( sscanf( ptr, "%lu", &uli ) == EOF ) {};            // check return code
         return uli;
 }
 long long int ato( const char * ptr ) {
         long long int lli;
-        if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}            // check return code
+        if ( sscanf( ptr, "%lld", &lli ) == EOF ) {};           // check return code
         return lli;
 }
 unsigned long long int ato( const char * ptr ) {
         unsigned long long int ulli;
-        if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}           // check return code
+        if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {};          // check return code
         return ulli;
 }
 float ato( const char * ptr ) {
         float f;
-        if ( sscanf( ptr, "%f", &f ) == EOF ) {}                        // check return code
+        if ( sscanf( ptr, "%f", &f ) == EOF ) {};                       // check return code
         return f;
 }
 double ato( const char * ptr ) {
         double d;
-        if ( sscanf( ptr, "%lf", &d ) == EOF ) {}                       // check return code
+        if ( sscanf( ptr, "%lf", &d ) == EOF ) {};                      // check return code
         return d;
 }
 long double ato( const char * ptr ) {
         long double ld;
-        if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}                      // check return code
+        printf( "FRED " );
+        if ( sscanf( ptr, "%.32Lf", &ld ) == EOF ) {};          // check return code
         return ld;
 }
 float _Complex ato( const char * ptr ) {
         float re, im;
-        if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}       // check return code
+        if ( sscanf( ptr, "%g%g", &re, &im ) == EOF ) {};       // check return code
         return re + im * _Complex_I;
 }
 double _Complex ato( const char * ptr ) {
         double re, im;
-        if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {} // check return code
+        if ( sscanf( ptr, "%.16lg%.16lg", &re, &im ) == EOF ) {}; // check return code
         return re + im * _Complex_I;
 }
 long double _Complex ato( const char * ptr ) {
         long double re, im;
-        if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}     // check return code
+        if ( sscanf( ptr, "%.32Lg%.32Lg", &re, &im ) == EOF ) {}; // check return code
         return re + im * _Complex_I;
 }