Changeset 37218fc for src

Timestamp:

Apr 11, 2016, 11:51:07 AM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

37f0da8

Parents:

3aba311 (diff), e55ca05 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

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

Conflicts:

src/Parser/ParseNode.h

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• GenPoly/Box.cc (modified) (32 diffs)
• GenPoly/ScopedMap.h (modified) (5 diffs)
• GenPoly/ScopedSet.h (added)
• InitTweak/InitModel.h (modified) (1 diff)
• Parser/ExpressionNode.cc (modified) (3 diffs)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/parser.cc (modified) (1 diff)
• Parser/parser.yy (modified) (2 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.h (modified) (1 diff)
• SymTab/AddVisit.h (modified) (3 diffs)
• SymTab/Indexer.cc (modified) (1 diff)
• SymTab/Indexer.h (modified) (1 diff)
• SymTab/Validate.cc (modified) (13 diffs)
• SynTree/Expression.cc (modified) (4 diffs)
• SynTree/Expression.h (modified) (3 diffs)
• SynTree/Mutator.cc (modified) (3 diffs)
• SynTree/Mutator.h (modified) (3 diffs)
• SynTree/SynTree.h (modified) (3 diffs)
• SynTree/Visitor.cc (modified) (3 diffs)
• SynTree/Visitor.h (modified) (3 diffs)
• Tuples/FlattenTuple.cc (modified) (1 diff)
• Tuples/FlattenTuple.h (modified) (1 diff)
• driver/cfa.cc (modified) (3 diffs)
• examples/io.c (added)
• examples/io.data (moved) (moved from src/examples/read.data )
• examples/rational.c (added)
• examples/rational.cc (added)
• examples/read.c (deleted)
• libcfa/Makefile.am (modified) (2 diffs)
• libcfa/Makefile.in (modified) (3 diffs)
• libcfa/fstream (modified) (3 diffs)
• libcfa/fstream.c (modified) (7 diffs)
• libcfa/iostream (modified) (4 diffs)
• libcfa/iostream.c (modified) (21 diffs)
• libcfa/limits (modified) (1 diff)
• libcfa/limits.c (added)
• libcfa/rational (added)
• libcfa/rational.c (added)
• libcfa/stdlib (modified) (4 diffs)
• libcfa/stdlib.c (modified) (2 diffs)

src/CodeGen/CodeGenerator.cc

@@ -455 +455 @@
 
         void CodeGenerator::visit( UntypedOffsetofExpr *offsetofExpr ) {
-                assert( false );
+                assert( false && "UntypedOffsetofExpr should not reach code generation" );
         }
 
@@ -464 +464 @@
                 output << ", " << mangleName( offsetofExpr->get_member() );
                 output << ")";
+        }
+
+        void CodeGenerator::visit( OffsetPackExpr *offsetPackExpr ) {
+                assert( false && "OffsetPackExpr should not reach code generation" );
         }
   

src/CodeGen/CodeGenerator.h

@@ -65 +65 @@
                 virtual void visit( UntypedOffsetofExpr *offsetofExpr );
                 virtual void visit( OffsetofExpr *offsetofExpr );
+                virtual void visit( OffsetPackExpr *offsetPackExpr );
                 virtual void visit( LogicalExpr *logicalExpr );
                 virtual void visit( ConditionalExpr *conditionalExpr );

src/GenPoly/Box.cc

@@ -30 +30 @@
 #include "FindFunction.h"
 #include "ScopedMap.h"
+#include "ScopedSet.h"
 #include "ScrubTyVars.h"
 
@@ -62 +63 @@
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 
-                /// Key for a unique concrete type; generic base type paired with type parameter list
-                struct ConcreteType {
-                        ConcreteType() : base(NULL), params() {}
-
-                        ConcreteType(AggregateDecl *_base, const std::list< Type* >& _params) : base(_base), params() { cloneAll(_params, params); }
-
-                        ConcreteType(const ConcreteType& that) : base(that.base), params() { cloneAll(that.params, params); }
+                /// Abstracts type equality for a list of parameter types
+                struct TypeList {
+                        TypeList() : params() {}
+                        TypeList( const std::list< Type* > &_params ) : params() { cloneAll(_params, params); }
+                        TypeList( std::list< Type* > &&_params ) : params( _params ) {}
+
+                        TypeList( const TypeList &that ) : params() { cloneAll(that.params, params); }
+                        TypeList( TypeList &&that ) : params( std::move( that.params ) ) {}
 
                         /// Extracts types from a list of TypeExpr*
-                        ConcreteType(AggregateDecl *_base, const std::list< TypeExpr* >& _params) : base(_base), params() {
+                        TypeList( const std::list< TypeExpr* >& _params ) : params() {
                                 for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) {
                                         params.push_back( (*param)->get_type()->clone() );
@@ -77 +79 @@
                         }
 
-                        ConcreteType& operator= (const ConcreteType& that) {
+                        TypeList& operator= ( const TypeList &that ) {
                                 deleteAll( params );
+
                                 params.clear();
-
-                                base = that.base;
                                 cloneAll( that.params, params );
 
@@ -87 +88 @@
                         }
 
-                        ~ConcreteType() { deleteAll( params ); }
-
-                        bool operator== (const ConcreteType& that) const {
-                                if ( base != that.base ) return false;
+                        TypeList& operator= ( TypeList &&that ) {
+                                deleteAll( params );
+
+                                params = std::move( that.params );
+
+                                return *this;
+                        }
+
+                        ~TypeList() { deleteAll( params ); }
+
+                        bool operator== ( const TypeList& that ) const {
+                                if ( params.size() != that.params.size() ) return false;
 
                                 SymTab::Indexer dummy;
-                                if ( params.size() != that.params.size() ) return false;
                                 for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {
                                         if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false;
@@ -100 +108 @@
                         }
 
-                        AggregateDecl *base;        ///< Base generic type
                         std::list< Type* > params;  ///< Instantiation parameters
                 };
 
-                /// Maps a concrete type to the some value, accounting for scope
-                template< typename Value >
+                /// Maps a key and a TypeList to the some value, accounting for scope
+                template< typename Key, typename Value >
                 class InstantiationMap {
-                        /// Information about a specific instantiation of a generic type
-                        struct Instantiation {
-                                ConcreteType key;  ///< Instantiation parameters for this type
-                                Value *value;      ///< Value for this instantiation
-
-                                Instantiation() : key(), value(0) {}
-                                Instantiation(const ConcreteType &_key, Value *_value) : key(_key), value(_value) {}
-                        };
-                        /// Map of generic types to instantiations of them
-                        typedef std::map< AggregateDecl*, std::vector< Instantiation > > Scope;
-
-                        std::vector< Scope > scopes;  ///< list of scopes, from outermost to innermost
+                        /// Wraps value for a specific (Key, TypeList) combination
+                        typedef std::pair< TypeList, Value* > Instantiation;
+                        /// List of TypeLists paired with their appropriate values
+                        typedef std::vector< Instantiation > ValueList;
+                        /// Underlying map type; maps keys to a linear list of corresponding TypeLists and values
+                        typedef ScopedMap< Key*, ValueList > InnerMap;
+
+                        InnerMap instantiations;  ///< instantiations
 
                 public:
                         /// Starts a new scope
-                        void beginScope() {
-                                Scope scope;
-                                scopes.push_back(scope);
-                        }
+                        void beginScope() { instantiations.beginScope(); }
 
                         /// Ends a scope
-                        void endScope() {
-                                scopes.pop_back();
-                        }
-
-                        /// Default constructor initializes with one scope
-                        InstantiationMap() { beginScope(); }
-
-//              private:
-                        /// Gets the value for the concrete instantiation of this type, assuming it has already been instantiated in the current scope.
-                        /// Returns NULL on none such.
-                        Value *lookup( AggregateDecl *generic, const std::list< TypeExpr* >& params ) {
-                                ConcreteType key(generic, params);
-                                // scan scopes from innermost out
-                                for ( typename std::vector< Scope >::const_reverse_iterator scope = scopes.rbegin(); scope != scopes.rend(); ++scope ) {
-                                        // skip scope if no instantiations of this generic type
-                                        typename Scope::const_iterator insts = scope->find( generic );
-                                        if ( insts == scope->end() ) continue;
-                                        // look through instantiations for matches to concrete type
-                                        for ( typename std::vector< Instantiation >::const_iterator inst = insts->second.begin(); inst != insts->second.end(); ++inst ) {
-                                                if ( inst->key == key ) return inst->value;
+                        void endScope() { instantiations.endScope(); }
+
+                        /// Gets the value for the (key, typeList) pair, returns NULL on none such.
+                        Value *lookup( Key *key, const std::list< TypeExpr* >& params ) const {
+                                TypeList typeList( params );
+                                
+                                // scan scopes for matches to the key
+                                for ( typename InnerMap::const_iterator insts = instantiations.find( key ); insts != instantiations.end(); insts = instantiations.findNext( insts, key ) ) {
+                                        for ( typename ValueList::const_reverse_iterator inst = insts->second.rbegin(); inst != insts->second.rend(); ++inst ) {
+                                                if ( inst->first == typeList ) return inst->second;
                                         }
                                 }
-                                // no matching instantiation found
+                                // no matching instantiations found
                                 return 0;
                         }
-                public:
-//                      StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)lookup( inst->get_baseStruct(), typeSubs ); }
-//                      UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)lookup( inst->get_baseUnion(), typeSubs ); }
-
-//              private:
-                        /// Adds a value for a concrete type to the current scope
-                        void insert( AggregateDecl *generic, const std::list< TypeExpr* > &params, Value *value ) {
-                                ConcreteType key(generic, params);
-                                scopes.back()[generic].push_back( Instantiation( key, value ) );
-                        }
-//              public:
-//                      void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { insert( inst->get_baseStruct(), typeSubs, decl ); }
-//                      void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { insert( inst->get_baseUnion(), typeSubs, decl ); }
+
+                        /// Adds a value for a (key, typeList) pair to the current scope
+                        void insert( Key *key, const std::list< TypeExpr* > &params, Value *value ) {
+                                instantiations[ key ].push_back( Instantiation( TypeList( params ), value ) );
+                        }
                 };
 
@@ -197 +179 @@
                         virtual void doEndScope();
                   private:
-                        /// 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 );
@@ -225 +205 @@
                         ObjectDecl *makeTemporary( Type *type );
 
-                        std::map< std::string, DeclarationWithType *> assignOps;
-                        ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;
-                        ScopedMap< std::string, DeclarationWithType* > adapters;
+                        std::map< std::string, DeclarationWithType *> assignOps;     ///< Currently known type variable assignment operators
+                        ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;  ///< Currently known assignment operators
+                        ScopedMap< std::string, DeclarationWithType* > adapters;     ///< Set of adapter functions in the current scope
+                        
                         DeclarationWithType *retval;
                         bool useRetval;
@@ -233 +214 @@
                 };
 
-                /// Moves polymorphic returns in function types to pointer-type parameters, adds type size and assertion parameters to parameter lists as well
+                /// * Moves polymorphic returns in function types to pointer-type parameters
+                /// * adds type size and assertion parameters to parameter lists
                 class Pass2 : public PolyMutator {
                   public:
@@ -244 +226 @@
                         virtual Type *mutate( PointerType *pointerType );
                         virtual Type *mutate( FunctionType *funcType );
+                        
                   private:
                         void addAdapters( FunctionType *functionType );
@@ -253 +236 @@
                 class GenericInstantiator : public DeclMutator {
                         /// Map of (generic type, parameter list) pairs to concrete type instantiations
-                        InstantiationMap< AggregateDecl > instantiations;
+                        InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
                         /// Namer for concrete types
                         UniqueName typeNamer;
@@ -278 +261 @@
                 };
 
-                /// Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference;
-                /// also fixes offsetof expressions.
-                class MemberExprFixer : public PolyMutator {
-                  public:
+                /// Replaces member and size/align/offsetof expressions on polymorphic generic types with calculated expressions.
+                /// * Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference
+                /// * Calculates polymorphic offsetof expressions from offset array
+                /// * Inserts dynamic calculation of polymorphic type layouts where needed
+                class PolyGenericCalculator : public PolyMutator {
+                public:
                         template< typename DeclClass >
                         DeclClass *handleDecl( DeclClass *decl, Type *type );
@@ -292 +277 @@
                         virtual Type *mutate( FunctionType *funcType );
                         virtual Expression *mutate( MemberExpr *memberExpr );
+                        virtual Expression *mutate( SizeofExpr *sizeofExpr );
+                        virtual Expression *mutate( AlignofExpr *alignofExpr );
                         virtual Expression *mutate( OffsetofExpr *offsetofExpr );
+                        virtual Expression *mutate( OffsetPackExpr *offsetPackExpr );
+
+                        virtual void doBeginScope();
+                        virtual void doEndScope();
+
+                private:
+                        /// Makes a new variable in the current scope with the given name, type & optional initializer
+                        ObjectDecl *makeVar( const std::string &name, Type *type, Initializer *init = 0 );
+                        /// returns true if the type has a dynamic layout; such a layout will be stored in appropriately-named local variables when the function returns
+                        bool findGeneric( Type *ty );
+                        /// adds type parameters to the layout call; will generate the appropriate parameters if needed
+                        void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams );
+                        
+                        ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
+                        ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
                 };
 
@@ -342 +344 @@
                 Pass2 pass2;
                 GenericInstantiator instantiator;
-                MemberExprFixer memberFixer;
+                PolyGenericCalculator polyCalculator;
                 Pass3 pass3;
                 
@@ -348 +350 @@
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
-//              instantiateGeneric( translationUnit );
                 instantiator.mutateDeclarationList( translationUnit );
-                mutateTranslationUnit/*All*/( translationUnit, memberFixer );
+                mutateTranslationUnit/*All*/( translationUnit, polyCalculator );
                 mutateTranslationUnit/*All*/( translationUnit, pass3 );
         }
@@ -653 +654 @@
 
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
-                        // if this is a polymorphic assignment function, put it in the map for this scope
+                        // if this is a assignment function, put it in the map for this scope
                         if ( Type *assignedType = isAssignment( functionDecl ) ) {
                                 if ( ! dynamic_cast< TypeInstType* >( assignedType ) ) {
@@ -743 +744 @@
                 }
 
-                Expression *Pass1::makeOffsetArray( StructInstType *ty ) {
-                        std::list< Declaration* > &baseMembers = ty->get_baseStruct()->get_members();
-
-                        // make a new temporary array
-                        Type *offsetType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                        std::stringstream lenGen;
-                        lenGen << baseMembers.size();
-                        ConstantExpr *lenExpr = new ConstantExpr( Constant( offsetType->clone(), lenGen.str() ) );
-                        ObjectDecl *arrayTemp = makeTemporary( new ArrayType( Type::Qualifiers(), offsetType, lenExpr, false, false ) );
-
-                        // build initializer list for temporary
-                        std::list< Initializer* > inits;
-                        for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) {
-                                DeclarationWithType *memberDecl;
-                                if ( DeclarationWithType *origMember = dynamic_cast< DeclarationWithType* >( *member ) ) {
-                                        memberDecl = origMember->clone();
-                                } else {
-                                        memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
-                                }
-                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
-                        }
-                        arrayTemp->set_init( new ListInit( inits ) );
-
-                        // return variable pointing to temporary
-                        return new VariableExpr( arrayTemp );
-                }
-
                 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 );
@@ -782 +756 @@
                                 if ( dynamic_cast< StructInstType* >( polyBase ) ) {
                                         if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) {
-                                                arg = appExpr->get_args().insert( arg, makeOffsetArray( argBaseStructType ) );
-                                                arg++;
+                                                // zero-length arrays are forbidden by C, so don't pass offset for empty struct
+                                                if ( ! argBaseStructType->get_baseStruct()->get_members().empty() ) {
+                                                        arg = appExpr->get_args().insert( arg, new OffsetPackExpr( argBaseStructType->clone() ) );
+                                                        arg++;
+                                                }
                                         } else {
                                                 throw SemanticError( "Cannot pass non-struct type for generic struct" );
@@ -931 +908 @@
                                         return;
                                 } else if ( arg->get_results().front()->get_isLvalue() ) {
-                                        // VariableExpr and MemberExpr are lvalues
-                                        arg = new AddressExpr( arg );
+                                        // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
+                                        if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
+                                                commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
+                                        } else {
+                                                arg = new AddressExpr( arg );
+                                        }
                                 } else {
                                         // use type computed in unification to declare boxed variables
@@ -1027 +1008 @@
                         } // for
                 }
-
-
 
                 FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
@@ -1428 +1407 @@
                                         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" );
+                                                // Add appropriate mapping to assignment expression environment
                                                 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 );
-                                                
+                                                assignExpr->get_env()->add( (*forallIt)->get_name(), formalType );
+
+                                                // skip types with no assign op (ftype/dtype)
+                                                if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue;
+
+                                                // find assignment operator for formal type
                                                 DeclarationWithType *assertAssign = 0;
                                                 if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) {
@@ -1453 +1430 @@
                                                         }
                                                 }
-                                                
-
+
+                                                // add inferred parameter for field assignment operator to assignment expression
+                                                std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
+                                                assert( ! asserts.empty() && "Type param needs assignment operator assertion" );
+                                                DeclarationWithType *actualDecl = asserts.front();
                                                 assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
                                                         = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) );
@@ -1587 +1567 @@
                         ObjectDecl newPtr( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0,
                                            new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
-//   ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
                         for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
                                 ObjectDecl *sizeParm, *alignParm;
@@ -1631 +1610 @@
                                         ++last;
 
-                                        if ( dynamic_cast< StructInstType* >( polyBase ) ) {
-                                                offsetParm = newPtr.clone();
-                                                offsetParm->set_name( offsetofName( polyBase ) );
-                                                last = funcType->get_parameters().insert( last, offsetParm );
-                                                ++last;
+                                        if ( StructInstType *polyBaseStruct = dynamic_cast< StructInstType* >( polyBase ) ) {
+                                                // NOTE zero-length arrays are illegal in C, so empty structs have no offset array
+                                                if ( ! polyBaseStruct->get_baseStruct()->get_members().empty() ) {
+                                                        offsetParm = newPtr.clone();
+                                                        offsetParm->set_name( offsetofName( polyBase ) );
+                                                        last = funcType->get_parameters().insert( last, offsetParm );
+                                                        ++last;
+                                                }
                                         }
 
@@ -1844 +1826 @@
 
                 template< typename DeclClass >
-                DeclClass * MemberExprFixer::handleDecl( DeclClass *decl, Type *type ) {
+                DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( type, scopeTyVars );
@@ -1854 +1836 @@
                 }
 
-                ObjectDecl * MemberExprFixer::mutate( ObjectDecl *objectDecl ) {
+                ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) {
                         return handleDecl( objectDecl, objectDecl->get_type() );
                 }
 
-                DeclarationWithType * MemberExprFixer::mutate( FunctionDecl *functionDecl ) {
+                DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
                         return handleDecl( functionDecl, functionDecl->get_functionType() );
                 }
 
-                TypedefDecl * MemberExprFixer::mutate( TypedefDecl *typedefDecl ) {
+                TypedefDecl * PolyGenericCalculator::mutate( TypedefDecl *typedefDecl ) {
                         return handleDecl( typedefDecl, typedefDecl->get_base() );
                 }
 
-                TypeDecl * MemberExprFixer::mutate( TypeDecl *typeDecl ) {
+                TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
                         scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
                         return Mutator::mutate( typeDecl );
                 }
 
-                Type * MemberExprFixer::mutate( PointerType *pointerType ) {
+                Type * PolyGenericCalculator::mutate( PointerType *pointerType ) {
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( pointerType, scopeTyVars );
@@ -1881 +1863 @@
                 }
 
-                Type * MemberExprFixer::mutate( FunctionType *functionType ) {
+                Type * PolyGenericCalculator::mutate( FunctionType *funcType ) {
                         TyVarMap oldtyVars = scopeTyVars;
-                        makeTyVarMap( functionType, scopeTyVars );
-
-                        Type *ret = Mutator::mutate( functionType );
+                        makeTyVarMap( funcType, scopeTyVars );
+
+                        // make sure that any type information passed into the function is accounted for
+                        for ( std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin(); fnParm != funcType->get_parameters().end(); ++fnParm ) {
+                                // condition here duplicates that in Pass2::mutate( FunctionType* )
+                                Type *polyBase = hasPolyBase( (*fnParm)->get_type(), scopeTyVars );
+                                if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) {
+                                        knownLayouts.insert( sizeofName( polyBase ) );
+                                }
+                        }
+                        
+                        Type *ret = Mutator::mutate( funcType );
 
                         scopeTyVars = oldtyVars;
@@ -1891 +1882 @@
                 }
 
-                Statement *MemberExprFixer::mutate( DeclStmt *declStmt ) {
+                Statement *PolyGenericCalculator::mutate( DeclStmt *declStmt ) {
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
-                                if ( isPolyType( objectDecl->get_type(), scopeTyVars ) ) {
+                                if ( findGeneric( objectDecl->get_type() ) ) {
                                         // change initialization of a polymorphic value object
                                         // to allocate storage with alloca
@@ -1945 +1936 @@
                 }
                 
-                Expression *MemberExprFixer::mutate( MemberExpr *memberExpr ) {
+                Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
                         Expression *expr = Mutator::mutate( memberExpr );
@@ -1962 +1953 @@
                         Type *objectType = hasPolyBase( objectDecl->get_type(), scopeTyVars, &tyDepth );
                         if ( ! objectType ) return memberExpr;
+                        findGeneric( objectType ); // ensure layout for this type is available
 
                         Expression *newMemberExpr = 0;
@@ -1993 +1985 @@
                 }
 
-                Expression *MemberExprFixer::mutate( OffsetofExpr *offsetofExpr ) {
+                ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
+                        ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, init );
+                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+                        return newObj;
+                }
+
+                void PolyGenericCalculator::addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams ) {
+                        for ( std::list< Type* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
+                                if ( findGeneric( *param ) ) {
+                                        // push size/align vars for a generic parameter back
+                                        layoutCall->get_args().push_back( new NameExpr( sizeofName( *param ) ) );
+                                        layoutCall->get_args().push_back( new NameExpr( alignofName( *param ) ) );
+                                } else {
+                                        layoutCall->get_args().push_back( new SizeofExpr( (*param)->clone() ) );
+                                        layoutCall->get_args().push_back( new AlignofExpr( (*param)->clone() ) );
+                                }
+                        }
+                }
+
+                /// returns true if any of the otype parameters have a dynamic layout and puts all otype parameters in the output list
+                bool findGenericParams( std::list< TypeDecl* > &baseParams, std::list< Expression* > &typeParams, std::list< Type* > &out ) {
+                        bool hasDynamicLayout = false;
+
+                        std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin();
+                        std::list< Expression* >::const_iterator typeParam = typeParams.begin();
+                        for ( ; baseParam != baseParams.end() && typeParam != typeParams.end(); ++baseParam, ++typeParam ) {
+                                // skip non-otype parameters
+                                if ( (*baseParam)->get_kind() != TypeDecl::Any ) continue;
+                                TypeExpr *typeExpr = dynamic_cast< TypeExpr* >( *typeParam );
+                                assert( typeExpr && "all otype parameters should be type expressions" );
+
+                                Type *type = typeExpr->get_type();
+                                out.push_back( type );
+                                if ( isPolyType( type ) ) hasDynamicLayout = true;
+                        }
+                        assert( baseParam == baseParams.end() && typeParam == typeParams.end() );
+
+                        return hasDynamicLayout;
+                }
+
+                bool PolyGenericCalculator::findGeneric( Type *ty ) {
+                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
+                                // duplicate logic from isPolyType()
+                                if ( env ) {
+                                        if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+                                                return findGeneric( newType );
+                                        } // if
+                                } // if
+                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {
+                                        // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set
+                                        return true;
+                                }
+                                return false;
+                        } else if ( StructInstType *structTy = dynamic_cast< StructInstType* >( ty ) ) {
+                                // check if this type already has a layout generated for it
+                                std::string sizeName = sizeofName( ty );
+                                if ( knownLayouts.find( sizeName ) != knownLayouts.end() ) return true;
+
+                                // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
+                                std::list< Type* > otypeParams;
+                                if ( ! findGenericParams( *structTy->get_baseParameters(), structTy->get_parameters(), otypeParams ) ) return false;
+
+                                // insert local variables for layout and generate call to layout function
+                                knownLayouts.insert( sizeName );  // done early so as not to interfere with the later addition of parameters to the layout call
+                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+
+                                int n_members = structTy->get_baseStruct()->get_members().size();
+                                if ( n_members == 0 ) {
+                                        // all empty structs have the same layout - size 1, align 1
+                                        makeVar( sizeName, layoutType, new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
+                                        makeVar( alignofName( ty ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
+                                        // NOTE zero-length arrays are forbidden in C, so empty structs have no offsetof array
+                                } else {
+                                        ObjectDecl *sizeVar = makeVar( sizeName, layoutType );
+                                        ObjectDecl *alignVar = makeVar( alignofName( ty ), layoutType->clone() );
+                                        ObjectDecl *offsetVar = makeVar( offsetofName( ty ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from( n_members ) ), false, false ) );
+
+                                        // generate call to layout function
+                                        UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( "__layoutof_" + structTy->get_baseStruct()->get_name() ) );
+                                        layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) );
+                                        layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) );
+                                        layoutCall->get_args().push_back( new VariableExpr( offsetVar ) );
+                                        addOtypeParamsToLayoutCall( layoutCall, otypeParams );
+
+                                        stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
+                                }
+
+                                return true;
+                        } else if ( UnionInstType *unionTy = dynamic_cast< UnionInstType* >( ty ) ) {
+                                // check if this type already has a layout generated for it
+                                std::string sizeName = sizeofName( ty );
+                                if ( knownLayouts.find( sizeName ) != knownLayouts.end() ) return true;
+
+                                // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
+                                std::list< Type* > otypeParams;
+                                if ( ! findGenericParams( *unionTy->get_baseParameters(), unionTy->get_parameters(), otypeParams ) ) return false;
+
+                                // insert local variables for layout and generate call to layout function
+                                knownLayouts.insert( sizeName );  // done early so as not to interfere with the later addition of parameters to the layout call
+                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+
+                                ObjectDecl *sizeVar = makeVar( sizeName, layoutType );
+                                ObjectDecl *alignVar = makeVar( alignofName( ty ), layoutType->clone() );
+
+                                // generate call to layout function
+                                UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( "__layoutof_" + unionTy->get_baseUnion()->get_name() ) );
+                                layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) );
+                                layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) );
+                                addOtypeParamsToLayoutCall( layoutCall, otypeParams );
+
+                                stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
+
+                                return true;
+                        }
+
+                        return false;
+                }
+
+                Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
+                        Type *ty = sizeofExpr->get_type();
+                        if ( findGeneric( ty ) ) {
+                                Expression *ret = new NameExpr( sizeofName( ty ) );
+                                delete sizeofExpr;
+                                return ret;
+                        }
+                        return sizeofExpr;
+                }
+
+                Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
+                        Type *ty = alignofExpr->get_type();
+                        if ( findGeneric( ty ) ) {
+                                Expression *ret = new NameExpr( alignofName( ty ) );
+                                delete alignofExpr;
+                                return ret;
+                        }
+                        return alignofExpr;
+                }
+
+                Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) {
                         // mutate, exiting early if no longer OffsetofExpr
                         Expression *expr = Mutator::mutate( offsetofExpr );
@@ -2000 +2130 @@
 
                         // only mutate expressions for polymorphic structs/unions
-                        Type *ty = isPolyType( offsetofExpr->get_type(), scopeTyVars );
-                        if ( ! ty ) return offsetofExpr;
-
+                        Type *ty = offsetofExpr->get_type();
+                        if ( ! findGeneric( ty ) ) return offsetofExpr;
+                        
                         if ( StructInstType *structType = dynamic_cast< StructInstType* >( ty ) ) {
                                 // replace offsetof expression by index into offset array
@@ -2018 +2148 @@
                 }
 
+                Expression *PolyGenericCalculator::mutate( OffsetPackExpr *offsetPackExpr ) {
+                        StructInstType *ty = offsetPackExpr->get_type();
+
+                        Expression *ret = 0;
+                        if ( findGeneric( ty ) ) {
+                                // pull offset back from generated type information
+                                ret = new NameExpr( offsetofName( ty ) );
+                        } else {
+                                std::string offsetName = offsetofName( ty );
+                                if ( knownOffsets.find( offsetName ) != knownOffsets.end() ) {
+                                        // use the already-generated offsets for this type
+                                        ret = new NameExpr( offsetName );
+                                } else {
+                                        knownOffsets.insert( offsetName );
+
+                                        std::list< Declaration* > &baseMembers = ty->get_baseStruct()->get_members();
+                                        Type *offsetType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+
+                                        // build initializer list for offset array
+                                        std::list< Initializer* > inits;
+                                        for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) {
+                                                DeclarationWithType *memberDecl;
+                                                if ( DeclarationWithType *origMember = dynamic_cast< DeclarationWithType* >( *member ) ) {
+                                                        memberDecl = origMember->clone();
+                                                } else {
+                                                        memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
+                                                }
+                                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
+                                        }
+
+                                        // build the offset array and replace the pack with a reference to it
+                                        ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from( baseMembers.size() ) ), false, false ),
+                                                        new ListInit( inits ) );
+                                        ret = new VariableExpr( offsetArray );
+                                }
+                        }
+
+                        delete offsetPackExpr;
+                        return ret;
+                }
+
+                void PolyGenericCalculator::doBeginScope() {
+                        knownLayouts.beginScope();
+                        knownOffsets.beginScope();
+                }
+
+                void PolyGenericCalculator::doEndScope() {
+                        knownLayouts.endScope();
+                        knownOffsets.beginScope();
+                }
+
 ////////////////////////////////////////// Pass3 ////////////////////////////////////////////////////
 

src/GenPoly/ScopedMap.h

@@ -17 +17 @@
 #define _SCOPEDMAP_H
 
+#include <cassert>
 #include <iterator>
 #include <map>
@@ -164 +165 @@
                 void endScope() {
                         scopes.pop_back();
+                        assert( ! scopes.empty() );
                 }
 
@@ -188 +190 @@
                         return end();
                 }
-                const_iterator find( const Key &key ) const { return const_iterator( find( key ) ); }
+                const_iterator find( const Key &key ) const {
+                                return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->find( key ) );
+                }
                 
                 /// Finds the given key in the outermost scope inside the given scope where it occurs
@@ -200 +204 @@
                         return end();
                 }
-                const_iterator findNext( const_iterator &it, const Key &key ) const { return const_iterator( findNext( it, key ) ); }
+                const_iterator findNext( const_iterator &it, const Key &key ) const {
+                                return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->findNext( it, key ) );
+                }
 
                 /// Inserts the given key-value pair into the outermost scope
@@ -208 +214 @@
                 }
                 std::pair< iterator, bool > insert( const Key &key, const Value &value ) { return insert( std::make_pair( key, value ) ); }
-                
+
+                Value& operator[] ( const Key &key ) {
+                        iterator slot = find( key );
+                        if ( slot != end() ) return slot->second;
+                        return insert( key, Value() ).first->second;
+                }
         };
 } // namespace GenPoly

src/InitTweak/InitModel.h

@@ -75 +75 @@
                         void visit( UntypedOffsetofExpr * ) { throw 0; }
                         void visit( OffsetofExpr * ) { throw 0; }
+                        void visit( OffsetPackExpr * ) { throw 0; }
                         void visit( AttrExpr * ) { throw 0; }
                         void visit( LogicalExpr * ) { throw 0; }

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Mar 13 12:34:38 2016
-// Update Count     : 272
+// Last Modified On : Fri Apr  8 15:43:05 2016
+// Update Count     : 296
 // 
 
@@ -22 +22 @@
 
 #include "ParseNode.h"
+#include "TypeData.h"
 #include "SynTree/Constant.h"
 #include "SynTree/Expression.h"
+#include "SynTree/Declaration.h"
 #include "Common/UnimplementedError.h"
 #include "parseutility.h"
@@ -872 +874 @@
 }
 
+
+CompoundLiteralNode::CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids ) : type( type ), kids( kids ) {}
+CompoundLiteralNode::CompoundLiteralNode( const CompoundLiteralNode &other ) : ExpressionNode( other ), type( other.type ), kids( other.kids ) {}
+
+CompoundLiteralNode::~CompoundLiteralNode() {
+        delete kids;
+        delete type;
+}
+
+CompoundLiteralNode *CompoundLiteralNode::clone() const {
+        return new CompoundLiteralNode( *this );
+}
+
+void CompoundLiteralNode::print( std::ostream &os, int indent ) const {
+        os << string( indent,' ' ) << "CompoundLiteralNode:" << endl;
+
+        os << string( indent + 2, ' ' ) << "type:" << endl;
+        if ( type != 0 )
+                type->print( os, indent + 4 );
+
+        os << string( indent + 2, ' ' ) << "initialization:" << endl;
+        if ( kids != 0 )
+                kids->printList( os, indent + 4 );
+}
+
+void CompoundLiteralNode::printOneLine( std::ostream &os, int indent ) const {
+        os << "( ";
+        if ( type ) type->print( os );
+        os << ", ";
+        if ( kids ) kids->printOneLine( os );
+        os << ") ";
+}
+
+Expression *CompoundLiteralNode::build() const {
+        Declaration * newDecl = type->build();                          // compound literal type
+        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
+                return new CompoundLiteralExpr( newDeclWithType->get_type(), kids->build() );
+        // these types do not have associated type information
+        } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
+                return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), kids->build() );
+        } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
+                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), kids->build() );
+        } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
+                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), kids->build() );
+        } else {
+                assert( false );
+        } // if
+}
+
+
 ExpressionNode *flattenCommas( ExpressionNode *list ) {
         if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Mon Apr 04 17:04:22 2016
-// Update Count     : 190
+// Last Modified On : Mon Apr 11 11:50:52 2016
+// Update Count     : 205
 //
 
@@ -538 +538 @@
 };
 
+class CompoundLiteralNode : public ExpressionNode {
+  public:
+        CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids );
+        CompoundLiteralNode( const CompoundLiteralNode &type );
+        ~CompoundLiteralNode();
+
+        virtual CompoundLiteralNode *clone() const;
+
+        DeclarationNode *get_type() const { return type; }
+        CompoundLiteralNode *set_type( DeclarationNode *t ) { type = t; return this; }
+
+        InitializerNode *get_initializer() const { return kids; }
+        CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; }
+
+        void print( std::ostream &, int indent = 0 ) const;
+        void printOneLine( std::ostream &, int indent = 0 ) const;
+
+        virtual Expression *build() const;
+  private:
+        DeclarationNode *type;
+        InitializerNode *kids;
+};
+
 template< typename SynTreeType, typename NodeType >
 void buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList ) {

src/Parser/parser.cc

@@ -5180 +5180 @@
 /* Line 1806 of yacc.c  */
 #line 374 "parser.yy"
-    { (yyval.en) = 0; }
+    { (yyval.en) = new CompoundLiteralNode( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ); }
     break;
 

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 24 16:16:16 2016
-// Update Count     : 1498
+// Last Modified On : Fri Apr  8 16:21:55 2016
+// Update Count     : 1508
 // 
 
@@ -372 +372 @@
                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), $1 ); }
         | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
-                { $$ = 0; }
+                { $$ = new CompoundLiteralNode( $2, new InitializerNode( $5, true ) ); }
         | postfix_expression '{' argument_expression_list '}' // CFA
                 {

src/ResolvExpr/AlternativeFinder.cc

@@ -848 +848 @@
         }
 
+        void AlternativeFinder::visit( OffsetPackExpr *offsetPackExpr ) {
+                alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) );
+        }
+
         void AlternativeFinder::resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env ) {
                 // assume no polymorphism

src/ResolvExpr/AlternativeFinder.h

@@ -59 +59 @@
                 virtual void visit( UntypedOffsetofExpr *offsetofExpr );
                 virtual void visit( OffsetofExpr *offsetofExpr );
+                virtual void visit( OffsetPackExpr *offsetPackExpr );
                 virtual void visit( AttrExpr *attrExpr );
                 virtual void visit( LogicalExpr *logicalExpr );

src/SymTab/AddVisit.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 16:14:32 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Jul 14 12:26:17 2015
-// Update Count     : 4
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Apr  7 14:42:21 2016
+// Update Count     : 5
 //
 
@@ -27 +27 @@
 
         template< typename Visitor >
-        inline void addVisitStatement( Statement *stmt, Visitor &visitor ) {
-                maybeAccept( stmt, visitor );
-///   if ( ! declsToAdd.empty() ) {
-///     CompoundStmt *compound = new CompoundStmt( noLabels );
-///     compound->get_kids().push_back( stmt );
-///     addDecls( declsToAdd, compound->get_kids(), compound->get_kids().end() );
-///   }
-        }
-
-        template< typename Visitor >
         inline void addVisit(CompoundStmt *compoundStmt, Visitor &visitor) {
                 addVisitStatementList( compoundStmt->get_kids(), visitor );
-        }
-
-        template< typename Visitor >
-        inline void addVisit(IfStmt *ifStmt, Visitor &visitor) {
-                addVisitStatement( ifStmt->get_thenPart(), visitor );
-                addVisitStatement( ifStmt->get_elsePart(), visitor );
-                maybeAccept( ifStmt->get_condition(), visitor );
-        }
-
-        template< typename Visitor >
-        inline void addVisit(WhileStmt *whileStmt, Visitor &visitor) {
-                addVisitStatement( whileStmt->get_body(), visitor );
-                maybeAccept( whileStmt->get_condition(), visitor );
-        }
-
-        template< typename Visitor >
-        inline void addVisit(ForStmt *forStmt, Visitor &visitor) {
-                addVisitStatement( forStmt->get_body(), visitor );
-                acceptAll( forStmt->get_initialization(), visitor );
-                maybeAccept( forStmt->get_condition(), visitor );
-                maybeAccept( forStmt->get_increment(), visitor );
         }
 
@@ -74 +43 @@
         }
 
-        template< typename Visitor >
-        inline void addVisit(CaseStmt *caseStmt, Visitor &visitor) {
-                addVisitStatementList( caseStmt->get_statements(), visitor );
-                maybeAccept( caseStmt->get_condition(), visitor );
-        }
-
-        template< typename Visitor >
-        inline void addVisit(CatchStmt *cathStmt, Visitor &visitor) {
-                addVisitStatement( cathStmt->get_body(), visitor );
-                maybeAccept( cathStmt->get_decl(), visitor );
-        }
+        // template< typename Visitor >
+        // inline void addVisit(CaseStmt *caseStmt, Visitor &visitor) {
+        //      addVisitStatementList( caseStmt->get_statements(), visitor );
+        //      maybeAccept( caseStmt->get_condition(), visitor );
+        // }
 } // namespace SymTab
 

src/SymTab/Indexer.cc

@@ -344 +344 @@
                 maybeAccept( offsetofExpr->get_type(), *this );
                 maybeAccept( offsetofExpr->get_member(), *this );
+        }
+
+        void Indexer::visit( OffsetPackExpr *offsetPackExpr ) {
+                acceptAllNewScope( offsetPackExpr->get_results(), *this );
+                maybeAccept( offsetPackExpr->get_type(), *this );
         }
 

src/SymTab/Indexer.h

@@ -59 +59 @@
                 virtual void visit( UntypedOffsetofExpr *offsetofExpr );
                 virtual void visit( OffsetofExpr *offsetofExpr );
+                virtual void visit( OffsetPackExpr *offsetPackExpr );
                 virtual void visit( AttrExpr *attrExpr );
                 virtual void visit( LogicalExpr *logicalExpr );

src/SymTab/Validate.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 17:31:39 2016
-// Update Count     : 226
+// Last Modified On : Thu Apr  7 16:45:30 2016
+// Update Count     : 243
 //
 
@@ -40 +40 @@
 #include <list>
 #include <iterator>
+#include "Common/utility.h"
+#include "Common/UniqueName.h"
 #include "Validate.h"
 #include "SynTree/Visitor.h"
 #include "SynTree/Mutator.h"
 #include "SynTree/Type.h"
+#include "SynTree/Expression.h"
 #include "SynTree/Statement.h"
 #include "SynTree/TypeSubstitution.h"
@@ -49 +52 @@
 #include "FixFunction.h"
 // #include "ImplementationType.h"
-#include "Common/utility.h"
-#include "Common/UniqueName.h"
+#include "GenPoly/DeclMutator.h"
 #include "AddVisit.h"
 #include "MakeLibCfa.h"
@@ -70 +72 @@
 
                 virtual void visit( CompoundStmt *compoundStmt );
-                virtual void visit( IfStmt *ifStmt );
-                virtual void visit( WhileStmt *whileStmt );
-                virtual void visit( ForStmt *forStmt );
                 virtual void visit( SwitchStmt *switchStmt );
                 virtual void visit( ChooseStmt *chooseStmt );
-                virtual void visit( CaseStmt *caseStmt );
-                virtual void visit( CatchStmt *catchStmt );
+                // virtual void visit( CaseStmt *caseStmt );
           private:
                 HoistStruct();
@@ -144 +142 @@
 
                 virtual void visit( CompoundStmt *compoundStmt );
-                virtual void visit( IfStmt *ifStmt );
-                virtual void visit( WhileStmt *whileStmt );
-                virtual void visit( ForStmt *forStmt );
                 virtual void visit( SwitchStmt *switchStmt );
                 virtual void visit( ChooseStmt *chooseStmt );
-                virtual void visit( CaseStmt *caseStmt );
-                virtual void visit( CatchStmt *catchStmt );
+                // virtual void visit( CaseStmt *caseStmt );
 
                 AutogenerateRoutines() : functionNesting( 0 ) {}
@@ -166 +160 @@
                 /// and return something if the return type is non-void.
                 static void checkFunctionReturns( std::list< Declaration * > & translationUnit );
-
           private:
                 virtual void visit( FunctionDecl * functionDecl );
@@ -202 +195 @@
         };
 
+        class CompoundLiteral : public GenPoly::DeclMutator {
+                DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
+
+                virtual DeclarationWithType * mutate( ObjectDecl *objectDecl );
+                virtual Expression *mutate( CompoundLiteralExpr *compLitExpr );
+        };
+
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 Pass1 pass1;
                 Pass2 pass2( doDebug, 0 );
                 Pass3 pass3( 0 );
+                CompoundLiteral compoundliteral;
+
                 EliminateTypedef::eliminateTypedef( translationUnit );
                 HoistStruct::hoistStruct( translationUnit );
@@ -211 +213 @@
                 acceptAll( translationUnit, pass2 );
                 ReturnChecker::checkFunctionReturns( translationUnit );
+                mutateAll( translationUnit, compoundliteral );
                 AutogenerateRoutines::autogenerateRoutines( translationUnit );
                 acceptAll( translationUnit, pass3 );
@@ -292 +295 @@
         }
 
-        void HoistStruct::visit( IfStmt *ifStmt ) {
-                addVisit( ifStmt, *this );
-        }
-
-        void HoistStruct::visit( WhileStmt *whileStmt ) {
-                addVisit( whileStmt, *this );
-        }
-
-        void HoistStruct::visit( ForStmt *forStmt ) {
-                addVisit( forStmt, *this );
-        }
-
         void HoistStruct::visit( SwitchStmt *switchStmt ) {
                 addVisit( switchStmt, *this );
@@ -312 +303 @@
         }
 
-        void HoistStruct::visit( CaseStmt *caseStmt ) {
-                addVisit( caseStmt, *this );
-        }
-
-        void HoistStruct::visit( CatchStmt *cathStmt ) {
-                addVisit( cathStmt, *this );
-        }
+        // void HoistStruct::visit( CaseStmt *caseStmt ) {
+        //      addVisit( caseStmt, *this );
+        // }
 
         void Pass1::visit( EnumDecl *enumDecl ) {
@@ -874 +861 @@
         }
 
-        void AutogenerateRoutines::visit( IfStmt *ifStmt ) {
-                visitStatement( ifStmt );
-        }
-
-        void AutogenerateRoutines::visit( WhileStmt *whileStmt ) {
-                visitStatement( whileStmt );
-        }
-
-        void AutogenerateRoutines::visit( ForStmt *forStmt ) {
-                visitStatement( forStmt );
-        }
-
         void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
                 visitStatement( switchStmt );
@@ -894 +869 @@
         }
 
-        void AutogenerateRoutines::visit( CaseStmt *caseStmt ) {
-                visitStatement( caseStmt );
-        }
-
-        void AutogenerateRoutines::visit( CatchStmt *cathStmt ) {
-                visitStatement( cathStmt );
-        }
+        // void AutogenerateRoutines::visit( CaseStmt *caseStmt ) {
+        //      visitStatement( caseStmt );
+        // }
 
         void ReturnChecker::checkFunctionReturns( std::list< Declaration * > & translationUnit ) {
@@ -1080 +1051 @@
         }
 
+        DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
+                storageclass = objectDecl->get_storageClass();
+                DeclarationWithType * temp = Mutator::mutate( objectDecl );
+                storageclass = DeclarationNode::NoStorageClass;
+                return temp;
+        }
+
+        Expression *CompoundLiteral::mutate( CompoundLiteralExpr *compLitExpr ) {
+                // transform [storage_class] ... (struct S){ 3, ... };
+                // into [storage_class] struct S temp =  { 3, ... };
+                static UniqueName indexName( "_compLit" );
+
+                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageclass, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() );
+                compLitExpr->set_type( 0 );
+                compLitExpr->set_initializer( 0 );
+                delete compLitExpr;
+                DeclarationWithType * newtempvar = mutate( tempvar );
+                addDeclaration( newtempvar );                                   // add modified temporary to current block
+                return new VariableExpr( newtempvar );
+        }
 } // namespace SymTab
 

src/SynTree/Expression.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed Dec 09 14:10:29 2015
-// Update Count     : 34
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Apr  8 17:16:23 2016
+// Update Count     : 40
 //
 
@@ -22 +22 @@
 
 #include "Type.h"
+#include "Initializer.h"
 #include "Expression.h"
 #include "Declaration.h"
@@ -211 +212 @@
 
         os << " of ";
+
+        if ( type ) {
+                type->print(os, indent + 2);
+        } else {
+                os << "<NULL>";
+        }
+
+        os << std::endl;
+        Expression::print( os, indent );
+}
+
+OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
+        add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+}
+
+OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {}
+
+OffsetPackExpr::~OffsetPackExpr() { delete type; }
+
+void OffsetPackExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Offset pack expression on ";
 
         if ( type ) {
@@ -443 +465 @@
 
 
+CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
+        add_result( type->clone() );
+}
+
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
+
+CompoundLiteralExpr::~CompoundLiteralExpr() {
+        delete initializer;
+        delete type;
+}
+
+void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
+        os << "Compound Literal Expression: " << std::endl;
+        if ( type ) type->print( os, indent + 2 );
+        if ( initializer ) initializer->print( os, indent + 2 );
+}
+
 
 std::ostream & operator<<( std::ostream & out, Expression * expr ) {

src/SynTree/Expression.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed Dec 09 14:10:21 2015
-// Update Count     : 19
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Apr  8 17:18:06 2016
+// Update Count     : 21
 //
 
@@ -362 +362 @@
 };
 
+/// Expression representing a pack of field-offsets for a generic type
+class OffsetPackExpr : public Expression {
+public:
+        OffsetPackExpr( StructInstType *type_, Expression *aname_ = 0 );
+        OffsetPackExpr( const OffsetPackExpr &other );
+        virtual ~OffsetPackExpr();
+
+        StructInstType *get_type() const { return type; }
+        void set_type( StructInstType *newValue ) { type = newValue; }
+
+        virtual OffsetPackExpr *clone() const { return new OffsetPackExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+
+private:
+        StructInstType *type;
+};
+
 /// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
 class AttrExpr : public Expression {
@@ -557 +577 @@
 };
 
+/// CompoundLiteralExpr represents a C99 'compound literal'
+class CompoundLiteralExpr : public Expression {
+  public:
+        CompoundLiteralExpr( Type * type, Initializer * initializer );
+        CompoundLiteralExpr( const CompoundLiteralExpr &other );
+        ~CompoundLiteralExpr();
+
+        Type * get_type() const { return type; }
+        void set_type( Type * t ) { type = t; }
+
+        Initializer * get_initializer() const { return initializer; }
+        void set_initializer( Initializer * i ) { initializer = i; }
+
+        virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Type * type;
+        Initializer * initializer;
+};
+
 std::ostream & operator<<( std::ostream & out, Expression * expr );
 

src/SynTree/Mutator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 17:28:20 2016
-// Update Count     : 12
+// Last Modified On : Fri Apr  1 18:05:16 2016
+// Update Count     : 16
 //
 
@@ -274 +274 @@
 }
 
+Expression *Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
+        mutateAll( offsetPackExpr->get_results(), *this );
+        offsetPackExpr->set_type( maybeMutate( offsetPackExpr->get_type(), *this ) );
+        return offsetPackExpr;
+}
+
 Expression *Mutator::mutate( AttrExpr *attrExpr ) {
         mutateAll( attrExpr->get_results(), *this );
@@ -334 +340 @@
         mutateAll( valofExpr->get_results(), *this );
         return valofExpr;
+}
+
+Expression *Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
+        mutateAll( compLitExpr->get_results(), *this );
+        compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) );
+        compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
+        return compLitExpr;
 }
 

src/SynTree/Mutator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 17:33:11 2016
-// Update Count     : 9
+// Last Modified On : Fri Apr  1 17:26:56 2016
+// Update Count     : 10
 //
 #include <cassert>
@@ -67 +67 @@
         virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr );
         virtual Expression* mutate( OffsetofExpr *offsetofExpr );
+        virtual Expression* mutate( OffsetPackExpr *offsetPackExpr );
         virtual Expression* mutate( AttrExpr *attrExpr );
         virtual Expression* mutate( LogicalExpr *logicalExpr );
@@ -76 +77 @@
         virtual Expression* mutate( AsmExpr *asmExpr );
         virtual Expression* mutate( UntypedValofExpr *valofExpr );
+        virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
 
         virtual Type* mutate( VoidType *basicType );

src/SynTree/SynTree.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 17:29:00 2016
-// Update Count     : 4
+// Last Modified On : Fri Apr  1 16:47:44 2016
+// Update Count     : 5
 //
 
@@ -72 +72 @@
 class UntypedOffsetofExpr;
 class OffsetofExpr;
+class OffsetPackExpr;
 class AttrExpr;
 class LogicalExpr;
@@ -81 +82 @@
 class AsmExpr;
 class UntypedValofExpr;
+class CompoundLiteralExpr;
 
 class Type;

src/SynTree/Visitor.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 17:29:23 2016
-// Update Count     : 16
+// Last Modified On : Fri Apr  1 18:05:13 2016
+// Update Count     : 18
 //
 
@@ -230 +230 @@
 }
 
+void Visitor::visit( OffsetPackExpr *offsetPackExpr ) {
+        acceptAll( offsetPackExpr->get_results(), *this );
+        maybeAccept( offsetPackExpr->get_type(), *this );
+}
+
 void Visitor::visit( AttrExpr *attrExpr ) {
         acceptAll( attrExpr->get_results(), *this );
@@ -282 +287 @@
         acceptAll( valofExpr->get_results(), *this );
         maybeAccept( valofExpr->get_body(), *this );
+}
+
+void Visitor::visit( CompoundLiteralExpr *compLitExpr ) {
+        acceptAll( compLitExpr->get_results(), *this );
+        maybeAccept( compLitExpr->get_type(), *this );
+        maybeAccept( compLitExpr->get_initializer(), *this );
 }
 

src/SynTree/Visitor.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 17:33:35 2016
-// Update Count     : 6
+// Last Modified On : Fri Apr  1 17:26:55 2016
+// Update Count     : 7
 //
 
@@ -67 +67 @@
         virtual void visit( UntypedOffsetofExpr *offsetofExpr );
         virtual void visit( OffsetofExpr *offsetofExpr );
+        virtual void visit( OffsetPackExpr *offsetPackExpr );
         virtual void visit( AttrExpr *attrExpr );
         virtual void visit( LogicalExpr *logicalExpr );
@@ -76 +77 @@
         virtual void visit( AsmExpr *asmExpr );
         virtual void visit( UntypedValofExpr *valofExpr );
+        virtual void visit( CompoundLiteralExpr *compLitExpr );
 
         virtual void visit( VoidType *basicType );

src/Tuples/FlattenTuple.cc

@@ -49 +49 @@
         void FlattenTuple::CollectArgs::visit( UntypedOffsetofExpr *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( OffsetofExpr        *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
+        void FlattenTuple::CollectArgs::visit( OffsetPackExpr      *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( AttrExpr            *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( LogicalExpr         *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }

src/Tuples/FlattenTuple.h

@@ -45 +45 @@
                         virtual void visit( UntypedOffsetofExpr * );
                         virtual void visit( OffsetofExpr * );
+                        virtual void visit( OffsetPackExpr * );
                         virtual void visit( AttrExpr * );
                         virtual void visit( LogicalExpr * );

src/driver/cfa.cc

@@ -10 +10 @@
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jan 28 18:24:06 2016
-// Update Count     : 127
+// Last Modified On : Wed Apr  6 14:04:22 2016
+// Update Count     : 132
 //
 
@@ -165 +165 @@
                                 nargs += 1;
                         } else if ( prefix( arg, "-std=" ) ) {
-                                std_flag = true;                                                // std=XX provided
+                                std_flag = true;                                                // -std=XX provided
                                 args[nargs] = argv[i];                                  // pass the argument along
                                 nargs += 1;
@@ -307 +307 @@
                 nargs += 1;
                 if ( ! std_flag ) {                                                             // default c99, if none specified
-                        args[nargs] = "-std=c99";
+                        args[nargs] = "-std=gnu99";
                         nargs += 1;
                 } // if

src/libcfa/Makefile.am

@@ -11 +11 @@
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Wed Mar  2 22:59:23 2016
-## Update Count     : 119
+## Last Modified On : Wed Apr  6 21:10:44 2016
+## Update Count     : 123
 ###############################################################################
 
@@ -60 +60 @@
         ${CC} ${CFLAGS} -c -o $@ $<
 
-libs = stdlib iostream fstream iterator
+libs = limits stdlib iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
 
-cheaders = #  expat
-cfaheaders = limits
+cheaders = # expat
+cfaheaders = # limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}
 

src/libcfa/Makefile.in

@@ -83 +83 @@
 libcfa_a_AR = $(AR) $(ARFLAGS)
 libcfa_a_LIBADD =
-am__objects_1 = stdlib.$(OBJEXT) iostream.$(OBJEXT) fstream.$(OBJEXT) \
-        iterator.$(OBJEXT)
+am__objects_1 = limits.$(OBJEXT) stdlib.$(OBJEXT) iostream.$(OBJEXT) \
+        fstream.$(OBJEXT) iterator.$(OBJEXT) rational.$(OBJEXT)
 am_libcfa_a_OBJECTS = libcfa-prelude.$(OBJEXT) $(am__objects_1)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
@@ -213 +213 @@
 MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} \
         ${addprefix ${libdir}/,${lib_LIBRARIES}} ${includedir}/*
-libs = stdlib iostream fstream iterator
+libs = limits stdlib iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
-cheaders = #  expat
-cfaheaders = limits
+cheaders = # expat
+cfaheaders = # limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}
 all: all-am
@@ -297 +297 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/iterator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa-prelude.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/limits.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rational.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stdlib.Po@am__quote@
 

src/libcfa/fstream

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 15:08:14 2016
-// Update Count     : 78
+// Last Modified On : Tue Apr  5 22:37:12 2016
+// Update Count     : 82
 //
 
@@ -20 +20 @@
 
 enum { separateSize = 16 };
-struct ofstream { void *file; int separate; char separator[separateSize]; };
+struct ofstream {
+        void *file;
+        _Bool sepDefault;
+        _Bool sepOnOff;
+        char separator[separateSize];
+}; // ofstream
 
 _Bool sepPrt( ofstream * );
 void sepOn( ofstream * );
 void sepOff( ofstream * );
+void sepReset( ofstream * );
+void sepReset( ofstream *, _Bool );
 void sepSet( ofstream *, const char * );
 const char * sepGet( ofstream * );
-void sepDisable( ofstream * );
-void sepEnable( ofstream * );
+_Bool sepDisable( ofstream * );
+_Bool sepEnable( ofstream * );
 int fail( ofstream * );
 int flush( ofstream * );
@@ -39 +46 @@
 
 // implement context istream
-struct ifstream { void *file; };
+struct ifstream {
+        void *file;
+}; // ifstream
 
 int fail( ifstream * is );

src/libcfa/fstream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Feb 29 18:41:10 2016
-// Update Count     : 162
+// Last Modified On : Wed Apr  6 17:55:27 2016
+// Update Count     : 176
 //
 
@@ -25 +25 @@
 }
 
-#define IO_MSG "I/O error "
+#define IO_MSG "I/O error: "
 
-_Bool sepPrt( ofstream * os ) { return os->separate == 1; }
-void sepOn( ofstream * os ) { if ( os->separate != 2 ) os->separate = 1; }
-void sepOff( ofstream * os ) { if ( os->separate != 2 ) os->separate = 0; }
+_Bool sepPrt( ofstream * os ) { return os->sepOnOff; }
+void sepOn( ofstream * os ) { os->sepOnOff = 1; }
+void sepOff( ofstream * os ) { os->sepOnOff = 0; }
+void sepReset( ofstream * os ) { os->sepOnOff = os->sepDefault; }
+void sepReset( ofstream * os, _Bool reset ) { os->sepDefault = reset; os->sepOnOff = os->sepDefault; }
 void sepSet( ofstream * os, const char * s ) {
         strncpy( &(os->separator[0]), s, separateSize - 1 );
@@ -35 +37 @@
 } // sepSet
 const char * sepGet( ofstream * os ) { return &(os->separator[0]); }
-void sepDisable( ofstream *os ) { os->separate = 2; }
-void sepEnable( ofstream *os ) { os->separate = 0; }
+_Bool sepDisable( ofstream *os ) {
+        _Bool temp = os->sepDefault;
+        os->sepDefault = 0;
+        sepReset( os );
+        return temp;
+} // sepDisable
+_Bool sepEnable( ofstream *os ) {
+        _Bool temp = os->sepDefault;
+        os->sepDefault = 1;
+        sepReset( os );
+        return temp;
+} // sepEnable
 
 int fail( ofstream * os ) {
@@ -49 +61 @@
         FILE *file = fopen( name, mode );
         if ( file == 0 ) {                                                                      // do not change unless successful
-                perror( IO_MSG "open output" );
+                fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
+                perror( 0 );
                 exit( EXIT_FAILURE );
         } // if
@@ -94 +107 @@
 
 
-static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 0, { ' ', '\0' } };
+static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 1, 0, { ' ', '\0' } };
 ofstream *sout = &soutFile;
-static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 0, { ' ', '\0' } };
+static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 1, 0, { ' ', '\0' } };
 ofstream *serr = &serrFile;
 
@@ -114 +127 @@
         FILE *t = fopen( name, mode );
         if ( t == 0 ) {                                                                         // do not change unless successful
-                perror( IO_MSG "open input" );
+                fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
+                perror( 0 );
                 exit( EXIT_FAILURE );
         } // if
@@ -175 +189 @@
 // Local Variables: //
 // tab-width: 4 //
-// compile-command: "cfa fstream.c" //
 // End: //

src/libcfa/iostream

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 18:05:27 2016
-// Update Count     : 85
+// Last Modified On : Tue Apr  5 22:32:37 2016
+// Update Count     : 90
 //
 
@@ -23 +23 @@
         void sepOn( ostype * );
         void sepOff( ostype * );
+        void sepReset( ostype * );
+        void sepReset( ostype *, _Bool );
         void sepSet( ostype *, const char * );
         const char * sepGet( ostype * );
-        void sepDisable( ostype * );
-        void sepEnable( ostype * );
+        _Bool sepDisable( ostype * );
+        _Bool sepEnable( ostype * );
         int fail( ostype * );
         int flush( ostype * );
@@ -67 +69 @@
 forall( dtype ostype | ostream( ostype ) ) ostype * sepOn( ostype * );
 forall( dtype ostype | ostream( ostype ) ) ostype * sepOff( ostype * );
+forall( dtype ostype | ostream( ostype ) ) ostype * sepDisable( ostype * );
+forall( dtype ostype | ostream( ostype ) ) ostype * sepEnable( ostype * );
 
 // writes the range [begin, end) to the given stream
@@ -110 +114 @@
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double _Complex * );
 
-struct _Istream_str1 { char * s; };
-_Istream_str1 str( char * );
-forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_str1 );
+struct _Istream_cstrUC { char * s; };
+_Istream_cstrUC cstr( char * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_cstrUC );
 
-struct _Istream_str2 { char * s; int size; };
-_Istream_str2 str( char *, int size );
-forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_str2 );
+struct _Istream_cstrC { char * s; int size; };
+_Istream_cstrC cstr( char *, int size );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_cstrC );
 
 #endif // __IOSTREAM_H__

src/libcfa/iostream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar  7 13:51:23 2016
-// Update Count     : 227
+// Last Modified On : Wed Apr  6 16:13:29 2016
+// Update Count     : 278
 //
 
@@ -27 +27 @@
 ostype * ?|?( ostype *os, char c ) {
         prtfmt( os, "%c", c );
+        sepOff( os );
         return os;
 } // ?|?
@@ -32 +33 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, short int si ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%hd", si );
         return os;
@@ -39 +41 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned short int usi ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%hu", usi );
         return os;
@@ -46 +49 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, int i ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%d", i );
         return os;
@@ -53 +57 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned int ui ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%u", ui );
         return os;
@@ -60 +65 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long int li ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%ld", li );
         return os;
@@ -67 +73 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned long int uli ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%lu", uli );
         return os;
@@ -74 +81 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long long int lli ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%lld", lli );
         return os;
@@ -81 +89 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned long long int ulli ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%llu", ulli );
         return os;
@@ -88 +97 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, float f ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%g", f );
         return os;
@@ -95 +105 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, double d ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%.*lg", DBL_DIG, d );
         return os;
@@ -102 +113 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long double ld ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%.*Lg", LDBL_DIG, ld );
         return os;
@@ -110 +122 @@
 ostype * ?|?( ostype *os, float _Complex fc ) {
         os | crealf( fc );
-        if ( cimagf( fc ) >= 0 ) os | '+';
-        os | "" | cimagf( fc ) | 'i';
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimagf( fc ) >= 0 ) os | '+';                                      // negative value prints '-'
+        os | cimagf( fc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?
@@ -118 +132 @@
 ostype * ?|?( ostype *os, double _Complex dc ) {
         os | creal( dc );
-        if ( cimag( dc ) >= 0 ) os | '+';
-        os | "" | cimag( dc ) | 'i';
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimag( dc ) >= 0 ) os | '+';                                       // negative value prints '-'
+        os | cimag( dc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?
@@ -126 +142 @@
 ostype * ?|?( ostype *os, long double _Complex ldc ) {
         os | creall( ldc );
-        if ( cimagl( ldc ) >= 0 ) os | '+';
-        os | "" | cimagl( ldc ) | 'i';
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimagl( ldc ) >= 0 ) os | '+';                                     // negative value prints '-'
+        os | cimagl( ldc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?
@@ -134 +152 @@
 ostype * ?|?( ostype *os, const char *cp ) {
         enum { Open = 1, Close, OpenClose };
-        static const char mask[256] = {
+        static const unsigned char mask[256] = {
                 // opening delimiters
                 ['('] : Open, ['['] : Open, ['{'] : Open,
-                ['$'] : Open, [L'£'] : Open, [L'¥'] : Open, [L'¢'] : Open, [L'¿'] : Open, [L'«'] : Open,
+                ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
                 // closing delimiters
                 [','] : Close, ['.'] : Close, [':'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
                 [')'] : Close, [']'] : Close, ['}'] : Close,
-                ['%'] : Close, [L'»'] : Close,
+                ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
                 // opening-closing delimiters
                 ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose,
+                ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
         }; // mask
 
@@ -149 +168 @@
         // null string => no separator
   if ( len == 0 ) { sepOff( os ); return os; }
-        // first character NOT spacing or closing punctuation => add left separator
-        if ( sepPrt( os ) && isspace( cp[0] ) == 0 && mask[ cp[0] ] != Close && mask[ cp[0] ] != OpenClose ) {
+        // first character IS NOT spacing or closing punctuation => add left separator
+        unsigned char ch = cp[0];                                                       // must make unsigned
+        if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
                 prtfmt( os, "%s", sepGet( os ) );
         } // if
         // last character IS spacing or opening punctuation => turn off separator for next item
         unsigned int posn = len - 1;
-        if ( isspace( cp[posn] ) || mask[ cp[posn] ] == Open || mask[ cp[posn] ] == OpenClose ) {
+        ch = cp[posn];                                                                          // must make unsigned
+        if ( mask[ ch ] == Open || mask[ ch ] == OpenClose ) {
                 sepOff( os );
         } else {
@@ -165 +186 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, const void *p ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%p", p );
         return os;
@@ -196 +218 @@
 } // sepOff
 
+forall( dtype ostype | ostream( ostype ) ) 
+ostype * sepEnable( ostype * os ) {
+        sepEnable( os );
+        return os;
+} // sepEnable
+
+forall( dtype ostype | ostream( ostype ) ) 
+ostype * sepDisable( ostype * os ) {
+        sepDisable( os );
+        return os;
+} // sepDisable
+
 //---------------------------------------
 
@@ -310 +344 @@
 } // ?|?
 
-_Istream_str1 str( char * s ) { _Istream_str1 s = { s }; return s; }
-forall( dtype istype | istream( istype ) )
-istype * ?|?( istype * is, _Istream_str1 str ) {
-        scanfmt( is, "%s", str.s );
-        return is;
-} // str
-
-_Istream_str2 str( char * s, int size ) { _Istream_str2 s = { s, size }; return s; }
-forall( dtype istype | istream( istype ) )
-istype * ?|?( istype * is, _Istream_str2 str ) {
+_Istream_cstrUC cstr( char * s ) { _Istream_cstrUC s = { s }; return s; }
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, _Istream_cstrUC cstr ) {
+        scanfmt( is, "%s", cstr.s );
+        return is;
+} // cstr
+
+_Istream_cstrC cstr( char * s, int size ) { _Istream_cstrC s = { s, size }; return s; }
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, _Istream_cstrC cstr ) {
         char buf[16];
-        sprintf( buf, "%%%ds", str.size );
-        scanfmt( is, buf, str.s );
-        return is;
-} // str
+        sprintf( buf, "%%%ds", cstr.size );
+        scanfmt( is, buf, cstr.s );
+        return is;
+} // cstr
 
 // Local Variables: //

src/libcfa/limits

@@ +1 @@
+// 
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+// 
+// limits -- 
+// 
+// Author           : Peter A. Buhr
+// Created On       : Wed Apr  6 18:06:52 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Apr  6 21:08:16 2016
+// Update Count     : 6
+// 
+
 // Integral Constants
 
-const short int MIN = -32768;
-const int MIN = -2147483648;
-const long int MIN = -9223372036854775807L - 1L;
-const long long int MIN = -9223372036854775807LL - 1LL;
+extern const short int MIN;
+extern const int MIN;
+extern const long int MIN;
+extern const long long int MIN;
 
-const short int MAX = 32767;
-const unsigned short int MAX = 65535;
-const int MAX = 2147483647;
-const unsigned int MAX = 4294967295_U;
-const long int MAX = 9223372036854775807_L;
-const unsigned long int MAX = 4294967295_U;
-const long long int MAX = 9223372036854775807_LL;
-const unsigned long long int MAX = 18446744073709551615_ULL;
+extern const short int MAX;
+extern const unsigned short int MAX;
+extern const int MAX;
+extern const unsigned int MAX;
+extern const long int MAX;
+extern const unsigned long int MAX;
+extern const long long int MAX;
+extern const unsigned long long int MAX;
 
 // Floating-Point Constants
 
-const float PI = 3.141592_F;                            // pi
-const float PI_2 = 1.570796_F;                          // pi / 2
-const float PI_4 = 0.7853981_F;                         // pi / 4
-const float _1_PI = 0.3183098_F;                        // 1 / pi
-const float _2_PI = 0.6366197_F;                        // 2 / pi
-const float _2_SQRT_PI = 1.128379_F;                    // 2 / sqrt(pi)
+extern const float PI;                                                                  // pi
+extern const float PI_2;                                                                // pi / 2
+extern const float PI_4;                                                                // pi / 4
+extern const float _1_PI;                                                               // 1 / pi
+extern const float _2_PI;                                                               // 2 / pi
+extern const float _2_SQRT_PI;                                                  // 2 / sqrt(pi)
 
-const double PI = 3.14159265358979323846_D;             // pi
-const double PI_2 = 1.57079632679489661923_D;           // pi / 2
-const double PI_4 = 0.78539816339744830962_D;           // pi / 4
-const double _1_PI = 0.31830988618379067154_D;          // 1 / pi
-const double _2_PI = 0.63661977236758134308_D;          // 2 / pi
-const double _2_SQRT_PI = 1.12837916709551257390_D;     // 2 / sqrt(pi)
+extern const double PI;                                                                 // pi
+extern const double PI_2;                                                               // pi / 2
+extern const double PI_4;                                                               // pi / 4
+extern const double _1_PI;                                                              // 1 / pi
+extern const double _2_PI;                                                              // 2 / pi
+extern const double _2_SQRT_PI;                                                 // 2 / sqrt(pi)
 
-const long double PI = 3.1415926535897932384626433832795029_DL; // pi
-const long double PI_2 = 1.5707963267948966192313216916397514_DL; // pi / 2
-const long double PI_4 = 0.7853981633974483096156608458198757_DL; // pi / 4
-const long double _1_PI = 0.3183098861837906715377675267450287_DL; // 1 / pi
-const long double _2_PI = 0.6366197723675813430755350534900574_DL; // 2 / pi
-const long double _2_SQRT_PI = 1.1283791670955125738961589031215452_DL; // 2 / sqrt(pi)
+extern const long double PI;                                                    // pi
+extern const long double PI_2;                                                  // pi / 2
+extern const long double PI_4;                                                  // pi / 4
+extern const long double _1_PI;                                                 // 1 / pi
+extern const long double _2_PI;                                                 // 2 / pi
+extern const long double _2_SQRT_PI;                                    // 2 / sqrt(pi)
 
-const _Complex PI = 3.14159265358979323846_D+0.0_iD;    // pi
-const _Complex PI_2 = 1.57079632679489661923_D+0.0_iD;  // pi / 2
-const _Complex PI_4 = 0.78539816339744830962_D+0.0_iD;  // pi / 4
-const _Complex _1_PI = 0.31830988618379067154_D+0.0_iD; // 1 / pi
-const _Complex _2_PI = 0.63661977236758134308_D+0.0_iD; // 2 / pi
-const _Complex _2_SQRT_PI = 1.12837916709551257390_D+0.0_iD; // 2 / sqrt(pi)
+extern const _Complex PI;                                                               // pi
+extern const _Complex PI_2;                                                             // pi / 2
+extern const _Complex PI_4;                                                             // pi / 4
+extern const _Complex _1_PI;                                                    // 1 / pi
+extern const _Complex _2_PI;                                                    // 2 / pi
+extern const _Complex _2_SQRT_PI;                                               // 2 / sqrt(pi)
 
-const long _Complex PI = 3.1415926535897932384626433832795029_L+0.0iL; // pi
-const long _Complex PI_2 = 1.5707963267948966192313216916397514_L+0.0iL; // pi / 2
-const long _Complex PI_4 = 0.7853981633974483096156608458198757_L+0.0iL; // pi / 4
-const long _Complex _1_PI = 0.3183098861837906715377675267450287_L+0.0iL; // 1 / pi
-const long _Complex _2_PI = 0.6366197723675813430755350534900574_L+0.0iL; // 2 / pi
-const long _Complex _2_SQRT_PI = 1.1283791670955125738961589031215452_L+0.0iL; // 2 / sqrt(pi)
+extern const long _Complex PI;                                                  // pi
+extern const long _Complex PI_2;                                                // pi / 2
+extern const long _Complex PI_4;                                                // pi / 4
+extern const long _Complex _1_PI;                                               // 1 / pi
+extern const long _Complex _2_PI;                                               // 2 / pi
+extern const long _Complex _2_SQRT_PI;                                  // 2 / sqrt(pi)
 
-const float E = 2.718281;                               // e
-const float LOG2_E = 1.442695;                          // log_2(e)
-const float LOG10_E = 0.4342944;                        // log_10(e)
-const float LN_2 = 0.6931471;                           // log_e(2)
-const float LN_10 = 2.302585;                           // log_e(10)
-const float SQRT_2 = 1.414213;                          // sqrt(2)
-const float _1_SQRT_2 = 0.7071067;                      // 1 / sqrt(2)
+extern const float E;                                                                   // e
+extern const float LOG2_E;                                                              // log_2(e)
+extern const float LOG10_E;                                                             // log_10(e)
+extern const float LN_2;                                                                // log_e(2)
+extern const float LN_10;                                                               // log_e(10)
+extern const float SQRT_2;                                                              // sqrt(2)
+extern const float _1_SQRT_2;                                                   // 1 / sqrt(2)
 
-const double E = 2.7182818284590452354_D;               // e
-const double LOG2_E = 1.4426950408889634074_D;          // log_2(e)
-const double LOG10_E = 0.43429448190325182765_D;        // log_10(e)
-const double LN_2 = 0.69314718055994530942_D;           // log_e(2)
-const double LN_10 = 2.30258509299404568402_D;          // log_e(10)
-const double SQRT_2 = 1.41421356237309504880_D;         // sqrt(2)
-const double _1_SQRT_2 = 0.70710678118654752440_D;      // 1 / sqrt(2)
+extern const double E;                                                                  // e
+extern const double LOG2_E;                                                             // log_2(e)
+extern const double LOG10_E;                                                    // log_10(e)
+extern const double LN_2;                                                               // log_e(2)
+extern const double LN_10;                                                              // log_e(10)
+extern const double SQRT_2;                                                             // sqrt(2)
+extern const double _1_SQRT_2;                                                  // 1 / sqrt(2)
 
-const long double E = 2.7182818284590452353602874713526625_DL; // e
-const long double LOG2_E = 1.4426950408889634073599246810018921_DL; // log_2(e)
-const long double LOG10_E = 0.4342944819032518276511289189166051_DL; // log_10(e)
-const long double LN_2 = 0.6931471805599453094172321214581766_DL; // log_e(2)
-const long double LN_10 = 2.3025850929940456840179914546843642_DL; // log_e(10)
-const long double SQRT_2 = 1.4142135623730950488016887242096981_DL; // sqrt(2)
-const long double _1_SQRT_2 = 0.7071067811865475244008443621048490_DL; // 1/sqrt(2)
+extern const long double E;                                                             // e
+extern const long double LOG2_E;                                                // log_2(e)
+extern const long double LOG10_E;                                               // log_10(e)
+extern const long double LN_2;                                                  // log_e(2)
+extern const long double LN_10;                                                 // log_e(10)
+extern const long double SQRT_2;                                                // sqrt(2)
+extern const long double _1_SQRT_2;                                             // 1/sqrt(2)
 
-const _Complex E = 2.7182818284590452354_D+0.0_iD;      // e
-const _Complex LOG2_E = 1.4426950408889634074_D+0.0_iD; // log_2(e)
-const _Complex LOG10_E = 0.43429448190325182765_D+0.0_iD; // log_10(e)
-const _Complex LN_2 = 0.69314718055994530942_D+0.0_iD;  // log_e(2)
-const _Complex LN_10 = 2.30258509299404568402_D+0.0_iD; // log_e(10)
-const _Complex SQRT_2 = 1.41421356237309504880_D+0.0_iD;        // sqrt(2)
-const _Complex _1_SQRT_2 = 0.70710678118654752440_D+0.0_iD; // 1 / sqrt(2)
+extern const _Complex E;                                                                // e
+extern const _Complex LOG2_E;                                                   // log_2(e)
+extern const _Complex LOG10_E;                                                  // log_10(e)
+extern const _Complex LN_2;                                                             // log_e(2)
+extern const _Complex LN_10;                                                    // log_e(10)
+extern const _Complex SQRT_2;                                                   // sqrt(2)
+extern const _Complex _1_SQRT_2;                                                // 1 / sqrt(2)
 
-const long _Complex E = 2.7182818284590452353602874713526625_L+0.0_iL; // e
-const long _Complex LOG2_E = 1.4426950408889634073599246810018921_L+0.0_iL; // log_2(e)
-const long _Complex LOG10_E = 0.4342944819032518276511289189166051_L+0.0_iL; // log_10(e)
-const long _Complex LN_2 = 0.6931471805599453094172321214581766_L+0.0_iL; // log_e(2)
-const long _Complex LN_10 = 2.3025850929940456840179914546843642_L+0.0_iL; // log_e(10)
-const long _Complex SQRT_2 = 1.4142135623730950488016887242096981_L+0.0_iL; // sqrt(2)
-const long _Complex _1_SQRT_2 = 0.7071067811865475244008443621048490_L+0.0_iL; // 1 / sqrt(2)
+extern const long _Complex E;                                                   // e
+extern const long _Complex LOG2_E;                                              // log_2(e)
+extern const long _Complex LOG10_E;                                             // log_10(e)
+extern const long _Complex LN_2;                                                // log_e(2)
+extern const long _Complex LN_10;                                               // log_e(10)
+extern const long _Complex SQRT_2;                                              // sqrt(2)
+extern const long _Complex _1_SQRT_2;                                   // 1 / sqrt(2)
+
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //

src/libcfa/stdlib

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 22 22:34:24 2016
-// Update Count     : 69
+// Last Modified On : Fri Apr  1 22:26:14 2016
+// Update Count     : 73
 //
 
@@ -18 +18 @@
 extern "C" {
 #include <stddef.h>                                                                             // size_t
+#include <math.h>                                                                               // floor
 } // extern "C"
 
@@ -80 +81 @@
 char abs( char );
 extern "C" {
-int abs( int );         // use default C routine for int
-} // extern
+int abs( int );                         // use default C routine for int
+} // extern "C"
 long int abs( long int );
 long long int abs( long long int );
@@ -90 +91 @@
 double _Complex abs( double _Complex );
 long double _Complex abs( long double _Complex );
+
+//---------------------------------------
+
+float floor( float );
+extern "C" {
+double floor( double );         // use C routine for double
+} // extern "C"
+long double floor( long double );
+
+float ceil( float );
+extern "C" {
+double ceil( double );          // use C routine for double
+} // extern "C"
+long double ceil( long double );
 
 //---------------------------------------

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 Mar 23 13:26:42 2016
-// Update Count     : 146
+// Last Modified On : Wed Mar 30 10:48:41 2016
+// Update Count     : 149
 //
 
@@ -243 +243 @@
 //---------------------------------------
 
+float floor( float v ) { return floorf( v ); }
+long double floor( long double v ) { return floorl( v ); }
+
+float ceil( float v ) { return ceilf( v ); }
+long double ceil( long double v ) { return ceill( v ); }
+
+//---------------------------------------
+
 void rand48seed( long int s ) { srand48( s ); }
 char rand48() { return mrand48(); }