Changes in / [e3e16bc:982832e]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• CodeGen/Generate.cc (modified) (2 diffs)
• Common/PassVisitor.h (modified) (1 diff)
• Common/PassVisitor.impl.h (modified) (2 diffs)
• Common/utility.h (modified) (1 diff)
• GenPoly/Box.cc (modified) (22 diffs)
• Parser/DeclarationNode.cc (modified) (1 diff)
• Parser/ExpressionNode.cc (modified) (7 diffs)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/lex.ll (modified) (6 diffs)
• Parser/parser.yy (modified) (12 diffs)
• ResolvExpr/CastCost.cc (modified) (1 diff)
• ResolvExpr/ConversionCost.cc (modified) (2 diffs)
• SymTab/Autogen.cc (modified) (8 diffs)
• SymTab/Validate.cc (modified) (10 diffs)
• SynTree/BasicType.cc (modified) (2 diffs)
• SynTree/Declaration.h (modified) (2 diffs)
• SynTree/Mutator.cc (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/ObjectDecl.cc (modified) (1 diff)
• SynTree/Statement.cc (modified) (1 diff)
• SynTree/Statement.h (modified) (1 diff)
• SynTree/Type.cc (modified) (3 diffs)
• libcfa/iostream (modified) (3 diffs)
• libcfa/iostream.c (modified) (6 diffs)
• tests/.expect/32/KRfunctions.txt (modified) (2 diffs)
• tests/.expect/32/attributes.txt (modified) (12 diffs)
• tests/.expect/32/declarationSpecifier.txt (modified) (26 diffs)
• tests/.expect/32/extension.txt (modified) (5 diffs)
• tests/.expect/32/gccExtensions.txt (modified) (7 diffs)
• tests/.expect/32/literals.txt (added)
• tests/.expect/64/KRfunctions.txt (modified) (2 diffs)
• tests/.expect/64/attributes.txt (modified) (12 diffs)
• tests/.expect/64/declarationSpecifier.txt (modified) (25 diffs)
• tests/.expect/64/extension.txt (modified) (5 diffs)
• tests/.expect/64/gccExtensions.txt (modified) (6 diffs)
• tests/.expect/64/literals.txt (added)
• tests/.expect/io.txt (modified) (1 diff)
• tests/.expect/user_literals.txt (modified) (1 diff)
• tests/Makefile.am (modified) (2 diffs)
• tests/Makefile.in (modified) (1 diff)
• tests/charStringConstants.c (deleted)
• tests/io.c (modified) (4 diffs)
• tests/io.data (modified) (1 diff)
• tests/literals.c (added)
• tests/user_literals.c (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -258 +258 @@
 
         void CodeGenerator::visit( TraitDecl * traitDecl ) {
-                assertf( ! genC, "TraitDecl nodes should not reach code generation." );
+                assertf( ! genC, "TraitDecls should not reach code generation." );
                 extension( traitDecl );
                 handleAggregate( traitDecl, "trait " );
@@ -271 +271 @@
 
         void CodeGenerator::visit( TypeDecl * typeDecl ) {
-                if ( genC ) {
-                        // really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes,
-                        // still to be done
-                        extension( typeDecl );
-                        output << "extern unsigned long " << typeDecl->get_name();
-                        if ( typeDecl->get_base() ) {
-                                output << " = sizeof( " << genType( typeDecl->get_base(), "", pretty, genC ) << " )";
-                        } // if
-                } else {
-                        output << typeDecl->genTypeString() << " " << typeDecl->get_name();
-                        if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->get_sized() ) {
-                                output << " | sized(" << typeDecl->get_name() << ")";
-                        }
-                        if ( ! typeDecl->get_assertions().empty() ) {
-                                output << " | { ";
-                                genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() );
-                                output << " }";
-                        }
+                assertf( ! genC, "TypeDecls should not reach code generation." );
+                output << typeDecl->genTypeString() << " " << typeDecl->get_name();
+                if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->get_sized() ) {
+                        output << " | sized(" << typeDecl->get_name() << ")";
+                }
+                if ( ! typeDecl->get_assertions().empty() ) {
+                        output << " | { ";
+                        genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() );
+                        output << " }";
                 }
         }

src/CodeGen/Generate.cc

@@ -33 +33 @@
                 /// Removes misc. nodes that should not exist in CodeGen
                 struct TreeCleaner {
-                        void visit( CompoundStmt * stmt );
+                        void previsit( CompoundStmt * stmt );
 
                         static bool shouldClean( Declaration * );
@@ -72 +72 @@
 
         namespace {
-                void TreeCleaner::visit( CompoundStmt * cstmt ) {
+                void TreeCleaner::previsit( CompoundStmt * cstmt ) {
                         filter( cstmt->kids, [](Statement * stmt) {
                                 if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {

src/Common/PassVisitor.h

@@ -147 +147 @@
         virtual Declaration* mutate( EnumDecl *aggregateDecl ) override final;
         virtual Declaration* mutate( TraitDecl *aggregateDecl ) override final;
-        virtual TypeDecl* mutate( TypeDecl *typeDecl ) override final;
+        virtual Declaration* mutate( TypeDecl *typeDecl ) override final;
         virtual Declaration* mutate( TypedefDecl *typeDecl ) override final;
         virtual AsmDecl* mutate( AsmDecl *asmDecl ) override final;

src/Common/PassVisitor.impl.h

@@ -506 +506 @@
 
 template< typename pass_type >
-TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
+Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
         MUTATE_START( node );
 
@@ -521 +521 @@
         indexerScopedMutate( node->init, *this );
 
-        MUTATE_END( TypeDecl, node );
+        MUTATE_END( Declaration, node );
 }
 

src/Common/utility.h

@@ -389 +389 @@
 }
 
+// -----------------------------------------------------------------------------
+// Helper struct and function to support
+// for ( val : lazy_map( container1, f ) ) {}
+// syntax to have a for each that iterates a container, mapping each element by applying f
+template< typename T, typename Func >
+struct lambda_iterate_t {
+        const T & ref;
+        std::function<Func> f;
+
+        struct iterator {
+                typedef decltype(begin(ref)) Iter;
+                Iter it;
+                std::function<Func> f;
+                iterator( Iter it, std::function<Func> f ) : it(it), f(f) {}
+                iterator & operator++() {
+                        ++it; return *this;
+                }
+                bool operator!=( const iterator &other ) const { return it != other.it; }
+                auto operator*() const -> decltype(f(*it)) { return f(*it); }
+        };
+
+        lambda_iterate_t( const T & ref, std::function<Func> f ) : ref(ref), f(f) {}
+
+        auto begin() const -> decltype(iterator(std::begin(ref), f)) { return iterator(std::begin(ref), f); }
+        auto end() const   -> decltype(iterator(std::end(ref), f)) { return iterator(std::end(ref), f); }
+};
+
+template< typename... Args >
+lambda_iterate_t<Args...> lazy_map( const Args &... args ) {
+        return lambda_iterate_t<Args...>( args...);
+}
+
+
+
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/Box.cc

@@ -27 +27 @@
 
 #include "CodeGen/OperatorTable.h"
+#include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/ScopedMap.h"            // for ScopedMap, ScopedMap<>::iter...
 #include "Common/SemanticError.h"        // for SemanticError
@@ -157 +158 @@
                 /// * Calculates polymorphic offsetof expressions from offset array
                 /// * Inserts dynamic calculation of polymorphic type layouts where needed
-                class PolyGenericCalculator final : public PolyMutator {
+                class PolyGenericCalculator final : public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
                 public:
-                        typedef PolyMutator Parent;
-                        using Parent::mutate;
-
                         PolyGenericCalculator();
 
-                        template< typename DeclClass >
-                        DeclClass *handleDecl( DeclClass *decl, Type *type );
-                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
-                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
-                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
-                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
-                        virtual Statement *mutate( DeclStmt *declStmt ) override;
-                        virtual Type *mutate( PointerType *pointerType ) override;
-                        virtual Type *mutate( FunctionType *funcType ) override;
-                        virtual Expression *mutate( MemberExpr *memberExpr ) override;
-                        virtual Expression *mutate( SizeofExpr *sizeofExpr ) override;
-                        virtual Expression *mutate( AlignofExpr *alignofExpr ) override;
-                        virtual Expression *mutate( OffsetofExpr *offsetofExpr ) override;
-                        virtual Expression *mutate( OffsetPackExpr *offsetPackExpr ) override;
-
-                        virtual void doBeginScope() override;
-                        virtual void doEndScope() override;
+                        void premutate( ObjectDecl *objectDecl );
+                        void premutate( FunctionDecl *functionDecl );
+                        void premutate( TypedefDecl *objectDecl );
+                        void premutate( TypeDecl *objectDecl );
+                        Declaration * postmutate( TypeDecl *TraitDecl );
+                        void premutate( PointerType *pointerType );
+                        void premutate( FunctionType *funcType );
+                        void premutate( DeclStmt *declStmt );
+                        Expression *postmutate( MemberExpr *memberExpr );
+                        Expression *postmutate( SizeofExpr *sizeofExpr );
+                        Expression *postmutate( AlignofExpr *alignofExpr );
+                        Expression *postmutate( OffsetofExpr *offsetofExpr );
+                        Expression *postmutate( OffsetPackExpr *offsetPackExpr );
+
+                        void beginScope();
+                        void endScope();
 
                 private:
@@ -194 +191 @@
                         /// Exits the type-variable scope
                         void endTypeScope();
+                        /// Enters a new scope for knowLayouts and knownOffsets and queues exit calls
+                        void beginGenericScope();
 
                         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
                         UniqueName bufNamer;                           ///< Namer for VLA buffers
+                        TyVarMap scopeTyVars;
                 };
 
@@ -250 +250 @@
                 Pass1 pass1;
                 Pass2 pass2;
-                PolyGenericCalculator polyCalculator;
+                PassVisitor<PolyGenericCalculator> polyCalculator;
                 Pass3 pass3;
 
@@ -256 +256 @@
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
-                mutateTranslationUnit/*All*/( translationUnit, polyCalculator );
+                mutateAll( translationUnit, polyCalculator );
                 mutateTranslationUnit/*All*/( translationUnit, pass3 );
         }
@@ -555 +555 @@
                 TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
-                        return Mutator::mutate( typeDecl );
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
                 }
 
@@ -762 +762 @@
                                 } else if ( arg->get_result()->get_lvalue() ) {
                                         // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                        // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
+                                        //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
+                                        //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
+                                        //              return;
+                                        //      }
+                                        // }
                                         arg =  generalizedLvalue( new AddressExpr( arg ) );
                                         if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
@@ -1353 +1359 @@
                                 return handleDecl( typeDecl );
                         } else {
-                                return Parent::mutate( typeDecl );
+                                return dynamic_cast<TypeDecl*>( Parent::mutate( typeDecl ) );
                         }
                 }
@@ -1466 +1472 @@
 
                 PolyGenericCalculator::PolyGenericCalculator()
-                        : Parent(), knownLayouts(), knownOffsets(), bufNamer( "_buf" ) {}
+                        : knownLayouts(), knownOffsets(), bufNamer( "_buf" ), scopeTyVars( TypeDecl::Data{} ) {}
 
                 void PolyGenericCalculator::beginTypeScope( Type *ty ) {
-                        scopeTyVars.beginScope();
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( ty, scopeTyVars );
                 }
 
-                void PolyGenericCalculator::endTypeScope() {
-                        scopeTyVars.endScope();
-                }
-
-                template< typename DeclClass >
-                DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
-                        beginTypeScope( type );
-                        // knownLayouts.beginScope();
-                        // knownOffsets.beginScope();
-
-                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
-
-                        // knownOffsets.endScope();
-                        // knownLayouts.endScope();
-                        endTypeScope();
-                        return ret;
-                }
-
-                ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) {
-                        return handleDecl( objectDecl, objectDecl->get_type() );
-                }
-
-                DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
-                        knownLayouts.beginScope();
-                        knownOffsets.beginScope();
-
-                        DeclarationWithType * decl = handleDecl( functionDecl, functionDecl->get_functionType() );
-                        knownOffsets.endScope();
-                        knownLayouts.endScope();
-                        return decl;
-                }
-
-                TypedefDecl * PolyGenericCalculator::mutate( TypedefDecl *typedefDecl ) {
-                        return handleDecl( typedefDecl, typedefDecl->get_base() );
-                }
-
-                TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
+                void PolyGenericCalculator::beginGenericScope() {
+                        GuardScope( *this );
+                }
+
+                void PolyGenericCalculator::premutate( ObjectDecl *objectDecl ) {
+                        beginTypeScope( objectDecl->get_type() );
+                }
+
+                void PolyGenericCalculator::premutate( FunctionDecl *functionDecl ) {
+                        beginGenericScope();
+
+                        beginTypeScope( functionDecl->get_functionType() );
+                }
+
+                void PolyGenericCalculator::premutate( TypedefDecl *typedefDecl ) {
+                        beginTypeScope( typedefDecl->get_base() );
+                }
+
+                void PolyGenericCalculator::premutate( TypeDecl * typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
-                        return Parent::mutate( typeDecl );
-                }
-
-                Type * PolyGenericCalculator::mutate( PointerType *pointerType ) {
+                }
+
+                Declaration * PolyGenericCalculator::postmutate( TypeDecl *typeDecl ) {
+                        if ( Type * base = typeDecl->base ) {
+                                // add size/align variables for opaque type declarations
+                                TypeInstType inst( Type::Qualifiers(), typeDecl->name, typeDecl );
+                                std::string typeName = mangleType( &inst );
+                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+
+                                ObjectDecl * sizeDecl = ObjectDecl::newObject( sizeofName( typeName ), layoutType, new SingleInit( new SizeofExpr( base->clone() ) ) );
+                                ObjectDecl * alignDecl = ObjectDecl::newObject( alignofName( typeName ), layoutType->clone(), new SingleInit( new AlignofExpr( base->clone() ) ) );
+
+                                // ensure that the initializing sizeof/alignof exprs are properly mutated
+                                sizeDecl->acceptMutator( *visitor );
+                                alignDecl->acceptMutator( *visitor );
+
+                                // can't use makeVar, because it inserts into stmtsToAdd and TypeDecls can occur at global scope
+                                declsToAddAfter.push_back( alignDecl );
+                                // replace with sizeDecl
+                                return sizeDecl;
+                        }
+                        return typeDecl;
+                }
+
+                void PolyGenericCalculator::premutate( PointerType *pointerType ) {
                         beginTypeScope( pointerType );
-
-                        Type *ret = Parent::mutate( pointerType );
-
-                        endTypeScope();
-                        return ret;
-                }
-
-                Type * PolyGenericCalculator::mutate( FunctionType *funcType ) {
+                }
+
+                void PolyGenericCalculator::premutate( FunctionType *funcType ) {
                         beginTypeScope( funcType );
 
@@ -1534 +1538 @@
                                 }
                         }
-
-                        Type *ret = Parent::mutate( funcType );
-
-                        endTypeScope();
-                        return ret;
-                }
-
-                Statement *PolyGenericCalculator::mutate( DeclStmt *declStmt ) {
+                }
+
+                void PolyGenericCalculator::premutate( DeclStmt *declStmt ) {
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
                                 if ( findGeneric( objectDecl->get_type() ) ) {
@@ -1550 +1549 @@
                                                 new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Kind::Char), new NameExpr( sizeofName( mangleType(declType) ) ),
                                                 true, false, std::list<Attribute*>{ new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } ) } ), 0 );
-                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newBuf ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) );
 
                                         delete objectDecl->get_init();
@@ -1556 +1555 @@
                                 }
                         }
-                        return Parent::mutate( declStmt );
                 }
 
@@ -1583 +1581 @@
                 }
 
-                Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
-                        // mutate, exiting early if no longer MemberExpr
-                        Expression *expr = Parent::mutate( memberExpr );
-                        memberExpr = dynamic_cast< MemberExpr* >( expr );
-                        if ( ! memberExpr ) return expr;
-
+                Expression *PolyGenericCalculator::postmutate( MemberExpr *memberExpr ) {
                         // only mutate member expressions for polymorphic types
                         int tyDepth;
@@ -1635 +1628 @@
                 ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
                         ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
-                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
                         return newObj;
                 }
@@ -1714 +1707 @@
                                         addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-                                        stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
+                                        stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
                                 }
 
@@ -1740 +1733 @@
                                 addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-                                stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
+                                stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
 
                                 return true;
@@ -1748 +1741 @@
                 }
 
-                Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
+                Expression *PolyGenericCalculator::postmutate( SizeofExpr *sizeofExpr ) {
                         Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
                         if ( findGeneric( ty ) ) {
@@ -1758 +1751 @@
                 }
 
-                Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
+                Expression *PolyGenericCalculator::postmutate( AlignofExpr *alignofExpr ) {
                         Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result();
                         if ( findGeneric( ty ) ) {
@@ -1768 +1761 @@
                 }
 
-                Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) {
-                        // mutate, exiting early if no longer OffsetofExpr
-                        Expression *expr = Parent::mutate( offsetofExpr );
-                        offsetofExpr = dynamic_cast< OffsetofExpr* >( expr );
-                        if ( ! offsetofExpr ) return expr;
-
+                Expression *PolyGenericCalculator::postmutate( OffsetofExpr *offsetofExpr ) {
                         // only mutate expressions for polymorphic structs/unions
                         Type *ty = offsetofExpr->get_type();
@@ -1793 +1781 @@
                 }
 
-                Expression *PolyGenericCalculator::mutate( OffsetPackExpr *offsetPackExpr ) {
+                Expression *PolyGenericCalculator::postmutate( OffsetPackExpr *offsetPackExpr ) {
                         StructInstType *ty = offsetPackExpr->get_type();
 
@@ -1832 +1820 @@
                 }
 
-                void PolyGenericCalculator::doBeginScope() {
+                void PolyGenericCalculator::beginScope() {
                         knownLayouts.beginScope();
                         knownOffsets.beginScope();
                 }
 
-                void PolyGenericCalculator::doEndScope() {
+                void PolyGenericCalculator::endScope() {
                         knownLayouts.endScope();
                         knownOffsets.endScope();
@@ -1894 +1882 @@
 
                         addToTyVarMap( typeDecl, scopeTyVars );
-                        return Mutator::mutate( typeDecl );
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
                 }
 

src/Parser/DeclarationNode.cc

@@ -333 +333 @@
 DeclarationNode * DeclarationNode::newTypeDecl( string * name, DeclarationNode * typeParams ) {
         DeclarationNode * newnode = new DeclarationNode;
+        newnode->name = name;
         newnode->type = new TypeData( TypeData::Symbolic );
         newnode->type->symbolic.isTypedef = false;
         newnode->type->symbolic.params = typeParams;
-        newnode->type->symbolic.name = name;
         return newnode;
 } // DeclarationNode::newTypeDecl

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 Sep  3 22:21:21 2017
-// Update Count     : 639
+// Last Modified On : Tue Sep 12 10:00:29 2017
+// Update Count     : 672
 //
 
@@ -49 +49 @@
 // type.
 
-extern const Type::Qualifiers noQualifiers;             // no qualifiers on constants
-
+extern const Type::Qualifiers noQualifiers;                             // no qualifiers on constants
+
+static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
+static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
+static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; }
 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
-static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
 static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
 static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
@@ -67 +69 @@
 
 Expression * build_constantInteger( string & str ) {
-        static const BasicType::Kind kind[2][3] = {
-                { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
-                { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
+        static const BasicType::Kind kind[2][5] = {
+                // short (h) must be before char (hh)
+                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
+                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
         };
 
@@ -76 +79 @@
 
         bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
-        int size;                                                                                       // 0 => int, 1 => long, 2 => long long
+        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => size_t
         unsigned long long int v;                                                       // converted integral value
         size_t last = str.length() - 1;                                         // last character of constant
         Expression * ret;
 
-        // ROB: what do we do with units on 0 and 1?
         // special constants
         if ( str == "0" ) {
@@ -107 +109 @@
 
         if ( v <= INT_MAX ) {                                                           // signed int
-                size = 0;
+                size = 2;
         } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
-                size = 0;
+                size = 2;
                 Unsigned = true;                                                                // unsigned
         } else if ( v <= LONG_MAX ) {                                           // signed long int
-                size = 1;
+                size = 3;
         } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
-                size = 1;
+                size = 3;
                 Unsigned = true;                                                                // unsigned long int
         } else if ( v <= LLONG_MAX ) {                                          // signed long long int
-                size = 2;
+                size = 4;
         } else {                                                                                        // unsigned long long int
-                size = 2;
+                size = 4;
                 Unsigned = true;                                                                // unsigned long long int
         } // if
+
+        // At least one digit in integer constant, so safe to backup while looking for suffix.
 
         if ( checkU( str[last] ) ) {                                            // suffix 'u' ?
                 Unsigned = true;
-                if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'l' ?
-                        size = 1;
-                        if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ?
-                                size = 2;
+                if ( checkL( str[last - 1] ) ) {                                // suffix 'l' ?
+                        size = 3;
+                        if ( checkL( str[last - 2] ) ) {                        // suffix "ll" ?
+                                size = 4;
                         } // if
+                } else if ( checkH( str[last - 1] ) ) {                 // suffix 'h' ?
+                        size = 0;
+                        if ( checkH( str[last - 2] ) ) {                        // suffix "hh" ?
+                                size = 1;
+                        } // if
+                        str.erase( last - size - 1, size + 1 );         // remove 'h'/"hh"
                 } // if
         } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
-                size = 1;
-                if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'll' ?
-                        size = 2;
-                        if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ?
+                size = 3;
+                if ( checkL( str[last - 1] ) ) {                                // suffix 'll' ?
+                        size = 4;
+                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
                                 Unsigned = true;
                         } // if
-                } else {
-                        if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ?
+                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
+                        Unsigned = true;
+                } // if
+        } else if ( checkH( str[ last ] ) ) {                           // suffix 'h' ?
+                size = 0;
+                if ( checkH( str[last - 1] ) ) {                                // suffix "hh" ?
+                        size = 1;
+                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
                                 Unsigned = true;
                         } // if
-                } // if
+                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
+                        Unsigned = true;
+                } // if
+                str.erase( last - size, size + 1 );                             // remove 'h'/"hh"
+        } else if ( checkZ( str[last] ) ) {                                     // suffix 'z' ?
+                size = 5;
+                str.erase( last, 1 );                                                   // remove 'z'
         } // if
 
         ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
+        if ( Unsigned && size < 2 ) {                                           // less than int ?
+                // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which eliminates warnings for large values.
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
+        } else if ( size == 5 ) {                                                       // explicit cast to size_t
+                ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), "size_t", false ) );
+        } // if
   CLEANUP:
         if ( units.length() != 0 ) {
@@ -247 +275 @@
 } // build_constantStr
 
+Expression * build_field_name_FLOATING_FRACTIONconstant( const string & str ) {
+        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
+        Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
+        delete &str;
+        return ret;
+} // build_field_name_FLOATING_FRACTIONconstant
+
+Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
+        if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
+        Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
+        delete &str;
+        return ret;
+} // build_field_name_FLOATING_DECIMALconstant
+
 Expression * build_field_name_FLOATINGconstant( const string & str ) {
         // str is of the form A.B -> separate at the . and return member expression
@@ -273 +315 @@
         return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) );
 } // build_field_name_fraction_constants
-
-Expression * build_field_name_REALFRACTIONconstant( const string & str ) {
-        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
-        Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
-        delete &str;
-        return ret;
-} // build_field_name_REALFRACTIONconstant
-
-Expression * build_field_name_REALDECIMALconstant( const string & str ) {
-        if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
-        Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
-        delete &str;
-        return ret;
-} // build_field_name_REALDECIMALconstant
 
 NameExpr * build_varref( const string * name ) {

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Sep  3 19:24:34 2017
-// Update Count     : 799
+// Last Modified On : Sun Sep 10 09:56:32 2017
+// Update Count     : 801
 //
 
@@ -166 +166 @@
 Expression * build_constantChar( std::string &str );
 Expression * build_constantStr( std::string &str );
+Expression * build_field_name_FLOATING_FRACTIONconstant( const std::string & str );
+Expression * build_field_name_FLOATING_DECIMALconstant( const std::string & str );
 Expression * build_field_name_FLOATINGconstant( const std::string & str );
 Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
-Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
-Expression * build_field_name_REALDECIMALconstant( const std::string & str );
 
 NameExpr * build_varref( const std::string * name );

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Thu Aug 31 21:30:10 2017
- * Update Count     : 598
+ * Last Modified On : Sun Sep 10 22:29:15 2017
+ * Update Count     : 620
  */
 
@@ -93 +93 @@
                                 // numeric constants, CFA: '_' in constant
 hex_quad {hex}("_"?{hex}){3}
-integer_suffix_opt ("_"?(([uU](("ll"|"LL"|[lL])[iI]|[iI]?("ll"|"LL"|[lL])?))|([iI](("ll"|"LL"|[lL])[uU]|[uU]?("ll"|"LL"|[lL])?))|(("ll"|"LL"|[lL])([iI][uU]|[uU]?[iI]?))))?
+length ("ll"|"LL"|[lL])|("hh"|"HH"|[hH])
+integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?{user_suffix_opt}
 
 octal_digits ({octal})|({octal}({octal}|"_")*{octal})
 octal_prefix "0""_"?
-octal_constant (("0")|({octal_prefix}{octal_digits})){integer_suffix_opt}{user_suffix_opt}
+octal_constant (("0")|({octal_prefix}{octal_digits})){integer_suffix_opt}
 
 nonzero_digits ({nonzero})|({nonzero}({decimal}|"_")*{decimal})
-decimal_constant {nonzero_digits}{integer_suffix_opt}{user_suffix_opt}
+decimal_constant {nonzero_digits}{integer_suffix_opt}
 
 hex_digits ({hex})|({hex}({hex}|"_")*{hex})
 hex_prefix "0"[xX]"_"?
-hex_constant {hex_prefix}{hex_digits}{integer_suffix_opt}{user_suffix_opt}
+hex_constant {hex_prefix}{hex_digits}{integer_suffix_opt}
 
                                 // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
-floating_suffix_opt ("_"?([fFdDlL][iI]?|[iI][lLfFdD]?|"DL"))?
+exponent "_"?[eE]"_"?[+-]?{decimal_digits}
+floating_suffix ([fFdDlL]?[iI]?)|([iI][lLfFdD])
+floating_suffix_opt ("_"?({floating_suffix}|"DL"))?{user_suffix_opt}
 decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
-real_decimal {decimal_digits}"."{exponent}?{floating_suffix_opt}{user_suffix_opt}
-real_fraction "."{decimal_digits}{exponent}?{floating_suffix_opt}{user_suffix_opt}
-real_constant {decimal_digits}{real_fraction}
-exponent "_"?[eE]"_"?[+-]?{decimal_digits}
-floating_constant (({real_constant}{exponent}?)|({decimal_digits}{exponent})){floating_suffix_opt}{user_suffix_opt}
+floating_decimal {decimal_digits}"."{exponent}?{floating_suffix_opt}
+floating_fraction "."{decimal_digits}{exponent}?{floating_suffix_opt}
+floating_constant ({decimal_digits}{exponent}{floating_suffix_opt})|({decimal_digits}{floating_fraction})
 
 binary_exponent "_"?[pP]"_"?[+-]?{decimal_digits}
-hex_fractional_constant ({hex_digits}?"."{hex_digits})|({hex_digits}".")
-hex_floating_constant {hex_prefix}(({hex_fractional_constant}{binary_exponent})|({hex_digits}{binary_exponent})){floating_suffix_opt}
+hex_floating_suffix_opt ("_"?({floating_suffix}))?{user_suffix_opt}
+hex_floating_fraction ({hex_digits}?"."{hex_digits})|({hex_digits}".")
+hex_floating_constant {hex_prefix}(({hex_floating_fraction}{binary_exponent})|({hex_digits}{binary_exponent})){hex_floating_suffix_opt}
 
                                 // character escape sequence, GCC: \e => esc character
 simple_escape "\\"[abefnrtv'"?\\]
-                                // ' stop highlighting
+                                // ' stop editor highlighting
 octal_escape "\\"{octal}("_"?{octal}){0,2}
 hex_escape "\\""x""_"?{hex_digits}
@@ -154 +156 @@
                                 /* line directives */
 ^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["].*"\n" {
-        /* " stop highlighting */
+        /* " stop editor highlighting */
         static char filename[FILENAME_MAX];                                     // temporarily store current source-file name
         char *end_num;
@@ -310 +312 @@
 {octal_constant} { NUMERIC_RETURN(INTEGERconstant); }
 {hex_constant}  { NUMERIC_RETURN(INTEGERconstant); }
-{real_decimal}  { NUMERIC_RETURN(REALDECIMALconstant); } // must appear before floating_constant
-{real_fraction} { NUMERIC_RETURN(REALFRACTIONconstant); } // must appear before floating_constant
+{floating_decimal}      { NUMERIC_RETURN(FLOATING_DECIMALconstant); } // must appear before floating_constant
+{floating_fraction}     { NUMERIC_RETURN(FLOATING_FRACTIONconstant); } // must appear before floating_constant
 {floating_constant}     { NUMERIC_RETURN(FLOATINGconstant); }
 {hex_floating_constant} { NUMERIC_RETURN(FLOATINGconstant); }
@@ -319 +321 @@
 <QUOTE>[^'\\\n]* { strtext->append( yytext, yyleng ); }
 <QUOTE>['\n]{user_suffix_opt}   { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); }
-                                /* ' stop highlighting */
+                                /* ' stop editor highlighting */
 
                                 /* string constant */
@@ -325 +327 @@
 <STRING>[^"\\\n]* { strtext->append( yytext, yyleng ); }
 <STRING>["\n]{user_suffix_opt}  { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); }
-                                /* " stop highlighting */
+                                /* " stop editor highlighting */
 
                                 /* common character/string constant */

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Sep  3 20:43:19 2017
-// Update Count     : 2742
+// Last Modified On : Mon Sep 11 18:12:00 2017
+// Update Count     : 2787
 //
 
@@ -43 +43 @@
 #define YYDEBUG_LEXER_TEXT (yylval)                                             // lexer loads this up each time
 #define YYDEBUG 1                                                                               // get the pretty debugging code to compile
+#define YYERROR_VERBOSE
 
 #undef __GNUC_MINOR__
@@ -62 +63 @@
 stack< LinkageSpec::Spec > linkageStack;
 
-void appendStr( string *to, string *from ) {
-        // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
-        to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) );
+bool appendStr( string & to, string & from ) {
+        // 1. Multiple strings are concatenated into a single string but not combined internally. The reason is that
+        //    "\x12" "3" is treated as 2 characters versus 1 because "escape sequences are converted into single members of
+        //    the execution character set just prior to adjacent string literal concatenation" (C11, Section 6.4.5-8). It is
+        //    easier to let the C compiler handle this case.
+        //
+        // 2. String encodings are transformed into canonical form (one encoding at start) so the encoding can be found
+        //    without searching the string, e.g.: "abc" L"def" L"ghi" => L"abc" "def" "ghi". Multiple encodings must match,
+        //    i.e., u"a" U"b" L"c" is disallowed.
+
+        if ( from[0] != '"' ) {                                                         // encoding ?
+                if ( to[0] != '"' ) {                                                   // encoding ?
+                        if ( to[0] != from[0] || to[1] != from[1] ) { // different encodings ?
+                                yyerror( "non-matching string encodings for string-literal concatenation" );
+                                return false;                                                   // parse error, must call YYERROR in action
+                        } else if ( from[1] == '8' ) {
+                                from.erase( 0, 1 );                                             // remove 2nd encoding
+                        } // if
+                } else {
+                        if ( from[1] == '8' ) {                                         // move encoding to start
+                                to = "u8" + to;
+                                from.erase( 0, 1 );                                             // remove 2nd encoding
+                        } else {
+                                to = from[0] + to;
+                        } // if
+                } // if
+                from.erase( 0, 1 );                                                             // remove 2nd encoding
+        } // if
+        to += " " + from;                                                                       // concatenated into single string
+        return true;
 } // appendStr
 
@@ -88 +116 @@
 bool forall = false;                                                                    // aggregate have one or more forall qualifiers ?
 %}
+
+%define parse.error verbose
 
 // Types declaration
@@ -146 +176 @@
 // overloading constants 0/1, e.g., x.1 is lexed as (x)(.1), where (.1) is a factional constant, but is semantically
 // converted into the tuple index (.)(1). e.g., 3.x
-%token<tok>     REALDECIMALconstant     REALFRACTIONconstant    FLOATINGconstant
+%token<tok>     FLOATING_DECIMALconstant        FLOATING_FRACTIONconstant       FLOATINGconstant
 
 // multi-character operators
@@ -315 +345 @@
 %precedence ELSE        // token precedence for start of else clause in IF/WAITFOR statement
 
+
 %start translation_unit                                                                 // parse-tree root
 
@@ -321 +352 @@
 
 // The grammar in the ANSI C standard is not strictly context-free, since it relies upon the distinct terminal symbols
-// "identifier" and "TYPEDEFname" that are lexically identical.  While it is possible to write a purely context-free
-// grammar, such a grammar would obscure the relationship between syntactic and semantic constructs.  Hence, this
-// grammar uses the ANSI style.
+// "identifier", "TYPEDEFname", and "TYPEGENname" that are lexically identical.  While it is possible to write a purely
+// context-free grammar, such a grammar would obscure the relationship between syntactic and semantic constructs.
+// Hence, this grammar uses the ANSI style.
 //
 // Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance, those
@@ -360 +391 @@
                 // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
         INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
-        | REALDECIMALconstant                                           { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
-        | REALFRACTIONconstant                                          { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
+        | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
+        | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
         | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
         | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( *$1 ) ); }
@@ -390 +421 @@
         | string_literal_list STRINGliteral
                 {
-                        appendStr( $1, $2 );                                            // append 2nd juxtaposed string to 1st
+                        if ( ! appendStr( *$1, *$2 ) ) YYERROR;         // append 2nd juxtaposed string to 1st
                         delete $2;                                                                      // allocated by lexer
                         $$ = $1;                                                                        // conversion from tok to str
@@ -434 +465 @@
         | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
-        | postfix_expression REALFRACTIONconstant                       // CFA, tuple index
-                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_REALFRACTIONconstant( *$2 ) ) ); }
+        | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
         | postfix_expression ARROW no_attr_identifier
                 {
@@ -479 +510 @@
 field:                                                                                                  // CFA, tuple field selector
         field_name
-        | REALDECIMALconstant field
-                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
-        | REALDECIMALconstant '[' push field_list pop ']'
-                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *$1 ) ), build_tuple( $4 ) ) ); }
+        | FLOATING_DECIMALconstant field
+                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
+        | FLOATING_DECIMALconstant '[' push field_list pop ']'
+                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $4 ) ) ); }
         | field_name '.' field
                 { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
@@ -507 +538 @@
         // empty
                 { $$ = nullptr; }
-        | fraction_constants REALFRACTIONconstant
-                {
-                        Expression * constant = build_field_name_REALFRACTIONconstant( *$2 );
+        | fraction_constants FLOATING_FRACTIONconstant
+                {
+                        Expression * constant = build_field_name_FLOATING_FRACTIONconstant( *$2 );
                         $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( $1,  constant ) ) : new ExpressionNode( constant );
                 }

src/ResolvExpr/CastCost.cc

@@ -45 +45 @@
                                 }
                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
-                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
                                 // all typedefs should be gone by this point
-                                assert( type );
+                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
                                 if ( type->get_base() ) {
                                         return castCost( src, type->get_base(), indexer, env ) + Cost::safe;

src/ResolvExpr/ConversionCost.cc

@@ -92 +92 @@
 
         Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
-                PRINT( std::cerr << "convert to reference cost..." << std::endl; )
+                PRINT( std::cerr << "convert to reference cost... diff " << diff << std::endl; )
                 if ( diff > 0 ) {
                         // TODO: document this
@@ -128 +128 @@
                         ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
                         assert( diff == -1 && destAsRef );
+                        PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; )
                         if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
                                 PRINT( std::cerr << "converting compatible base type" << std::endl; )

src/SymTab/Autogen.cc

@@ -163 +163 @@
                 // Routines at global scope marked "static" to prevent multiple definitions in separate translation units
                 // because each unit generates copies of the default routines for each aggregate.
-//              DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static;
                 Type::StorageClasses scs = functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static );
                 LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen;
@@ -186 +185 @@
         /// using map and t, determines if is constructable, etc.
         bool lookup( const TypeMap & map, Type * t ) {
+                assertf( t, "Autogenerate lookup was given non-type: %s", toString( t ).c_str() );
                 if ( dynamic_cast< PointerType * >( t ) ) {
                         // will need more complicated checking if we want this to work with pointer types, since currently
@@ -200 +200 @@
 
         /// using map and aggr, examines each member to determine if constructor, etc. should be generated
-        template<typename AggrDecl>
-        bool shouldGenerate( const TypeMap & map, AggrDecl * aggr ) {
-                for ( Declaration * dcl : aggr->get_members() ) {
-                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( dcl ) ) {
-                                if ( ! lookup( map, dwt->get_type() ) ) return false;
-                        }
+        template<typename Container>
+        bool shouldGenerate( const TypeMap & map, const Container & container ) {
+                for ( Type * t : container ) {
+                        if ( ! lookup( map, t ) ) return false;
                 }
                 return true;
@@ -211 +209 @@
 
         /// data structure for abstracting the generation of special functions
-        template< typename OutputIterator >
+        template< typename OutputIterator, typename Container >
         struct FuncGenerator {
-                StructDecl *aggregateDecl;
-                StructInstType *refType;
+                const Container & container;
+                Type *refType;
                 unsigned int functionNesting;
                 const std::list< TypeDecl* > & typeParams;
                 OutputIterator out;
-                FuncGenerator( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) : aggregateDecl( aggregateDecl ), refType( refType ), functionNesting( functionNesting ), typeParams( typeParams ), out( out ) {}
+                FuncGenerator( const Container & container, Type *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) : container( container ), refType( refType ), functionNesting( functionNesting ), typeParams( typeParams ), out( out ) {}
 
                 /// generates a function (?{}, ?=?, ^?{}) based on the data argument and members. If function is generated, inserts the type into the map.
                 void gen( const FuncData & data, bool concurrent_type ) {
-                        if ( ! shouldGenerate( data.map, aggregateDecl ) ) return;
+                        if ( ! shouldGenerate( data.map, container ) ) return;
                         FunctionType * ftype = data.genType( refType );
 
                         if(concurrent_type && CodeGen::isDestructor( data.fname )) {
-                                ftype->get_parameters().front()->get_type()->set_mutex( true );
-                        }
-
-                        cloneAll( typeParams, ftype->get_forall() );
+                                ftype->parameters.front()->get_type()->set_mutex( true );
+                        }
+
+                        cloneAll( typeParams, ftype->forall );
                         *out++ = genFunc( data.fname, ftype, functionNesting );
                         data.map.insert( Mangler::mangleType( refType ), true );
@@ -235 +233 @@
         };
 
-        template< typename OutputIterator >
-        FuncGenerator<OutputIterator> makeFuncGenerator( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) {
-                return FuncGenerator<OutputIterator>( aggregateDecl, refType, functionNesting, typeParams, out );
+        template< typename OutputIterator, typename Container >
+        FuncGenerator<OutputIterator, Container> makeFuncGenerator( const Container & container, Type *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) {
+                return FuncGenerator<OutputIterator, Container>( container, refType, functionNesting, typeParams, out );
         }
 
@@ -393 +391 @@
         }
 
+        Type * declToType( Declaration * decl ) {
+                if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                        return dwt->get_type();
+                }
+                return nullptr;
+        }
+
         /// generates struct constructors, destructor, and assignment functions
         void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
@@ -406 +411 @@
                 // generate each of the functions based on the supplied FuncData objects
                 std::list< FunctionDecl * > newFuncs;
-                auto generator = makeFuncGenerator( aggregateDecl, refType, functionNesting, typeParams, back_inserter( newFuncs ) );
+                // structure that iterates aggregate decl members, returning their types
+                auto generator = makeFuncGenerator( lazy_map( aggregateDecl->members, declToType ), refType, functionNesting, typeParams, back_inserter( newFuncs ) );
                 for ( const FuncData & d : data ) {
                         generator.gen( d, aggregateDecl->is_thread() || aggregateDecl->is_monitor() );
@@ -605 +611 @@
         }
 
+        Type * declToTypeDeclBase( Declaration * decl ) {
+                if ( TypeDecl * td = dynamic_cast< TypeDecl * >( decl ) ) {
+                        return td->base;
+                }
+                return nullptr;
+        }
+
+        // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
         void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
-                TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
-                typeInst->set_baseType( typeDecl );
-                ObjectDecl *src = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr );
-                ObjectDecl *dst = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr );
-
-                std::list< Statement * > stmts;
-                if ( typeDecl->get_base() ) {
-                        // xxx - generate ctor/dtors for typedecls, e.g.
-                        // otype T = int *;
-                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
-                        assign->get_args().push_back( new CastExpr( new VariableExpr( dst ), new PointerType( Type::Qualifiers(), typeDecl->get_base()->clone() ) ) );
-                        assign->get_args().push_back( new CastExpr( new VariableExpr( src ), typeDecl->get_base()->clone() ) );
-                        stmts.push_back( new ReturnStmt( std::list< Label >(), assign ) );
-                } // if
-                FunctionType *type = new FunctionType( Type::Qualifiers(), false );
-                type->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, typeInst, 0 ) );
-                type->get_parameters().push_back( dst );
-                type->get_parameters().push_back( src );
-                FunctionDecl *func = genFunc( "?=?", type, functionNesting );
-                func->get_statements()->get_kids() = stmts;
-                declsToAddAfter.push_back( func );
+                if ( ! typeDecl->base ) return;
+
+                // generate each of the functions based on the supplied FuncData objects
+                std::list< FunctionDecl * > newFuncs;
+                std::list< Declaration * > tds { typeDecl };
+                std::list< TypeDecl * > typeParams;
+                TypeInstType refType( Type::Qualifiers(), typeDecl->name, typeDecl );
+                auto generator = makeFuncGenerator( lazy_map( tds, declToTypeDeclBase ), &refType, functionNesting, typeParams, back_inserter( newFuncs ) );
+                for ( const FuncData & d : data ) {
+                        generator.gen( d, false );
+                }
+
+                if ( functionNesting == 0 ) {
+                        // forward declare if top-level struct, so that
+                        // type is complete as soon as its body ends
+                        // Note: this is necessary if we want structs which contain
+                        // generic (otype) structs as members.
+                        for ( FunctionDecl * dcl : newFuncs ) {
+                                addForwardDecl( dcl, declsToAddAfter );
+                        }
+                }
+
+                for ( FunctionDecl * dcl : newFuncs ) {
+                        FunctionType * ftype = dcl->type;
+                        assertf( ftype->parameters.size() == 1 || ftype->parameters.size() == 2, "Incorrect number of parameters in autogenerated typedecl function: %zd", ftype->parameters.size() );
+                        DeclarationWithType * dst = ftype->parameters.front();
+                        DeclarationWithType * src = ftype->parameters.size() == 2 ? ftype->parameters.back() : nullptr;
+                        // generate appropriate calls to member ctor, assignment
+                        // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor
+                        UntypedExpr * expr = new UntypedExpr( new NameExpr( dcl->name ) );
+                        expr->args.push_back( new CastExpr( new VariableExpr( dst ), new ReferenceType( Type::Qualifiers(), typeDecl->base->clone() ) ) );
+                        if ( src ) expr->args.push_back( new CastExpr( new VariableExpr( src ), typeDecl->base->clone() ) );
+                        dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) );
+                        if ( CodeGen::isAssignment( dcl->get_name() ) ) {
+                                // assignment needs to return a value
+                                FunctionType * assignType = dcl->type;
+                                assert( assignType->parameters.size() == 2 );
+                                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.back() );
+                                dcl->statements->kids.push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                        }
+                        declsToAddAfter.push_back( dcl );
+                }
         }
 

src/SymTab/Validate.cc

@@ -176 +176 @@
         };
 
-        class EliminateTypedef : public Mutator {
-          public:
+        struct EliminateTypedef final : public WithVisitorRef<EliminateTypedef>, public WithGuards {
                 EliminateTypedef() : scopeLevel( 0 ) {}
                 /// Replaces typedefs by forward declarations
                 static void eliminateTypedef( std::list< Declaration * > &translationUnit );
+
+                Type * postmutate( TypeInstType * aggregateUseType );
+                Declaration * postmutate( TypedefDecl * typeDecl );
+                void premutate( TypeDecl * typeDecl );
+                void premutate( FunctionDecl * funcDecl );
+                void premutate( ObjectDecl * objDecl );
+                DeclarationWithType * postmutate( ObjectDecl * objDecl );
+
+                void premutate( CastExpr * castExpr );
+
+                void premutate( CompoundStmt * compoundStmt );
+                CompoundStmt * postmutate( CompoundStmt * compoundStmt );
+
+                void premutate( StructDecl * structDecl );
+                Declaration * postmutate( StructDecl * structDecl );
+                void premutate( UnionDecl * unionDecl );
+                Declaration * postmutate( UnionDecl * unionDecl );
+                void premutate( EnumDecl * enumDecl );
+                Declaration * postmutate( EnumDecl * enumDecl );
+                Declaration * postmutate( TraitDecl * contextDecl );
+
           private:
-                virtual Declaration *mutate( TypedefDecl *typeDecl );
-                virtual TypeDecl *mutate( TypeDecl *typeDecl );
-                virtual DeclarationWithType *mutate( FunctionDecl *funcDecl );
-                virtual DeclarationWithType *mutate( ObjectDecl *objDecl );
-                virtual CompoundStmt *mutate( CompoundStmt *compoundStmt );
-                virtual Type *mutate( TypeInstType *aggregateUseType );
-                virtual Expression *mutate( CastExpr *castExpr );
-
-                virtual Declaration *mutate( StructDecl * structDecl );
-                virtual Declaration *mutate( UnionDecl * unionDecl );
-                virtual Declaration *mutate( EnumDecl * enumDecl );
-                virtual Declaration *mutate( TraitDecl * contextDecl );
-
                 template<typename AggDecl>
                 AggDecl *handleAggregate( AggDecl * aggDecl );
@@ -667 +674 @@
 
         void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
-                EliminateTypedef eliminator;
+                PassVisitor<EliminateTypedef> eliminator;
                 mutateAll( translationUnit, eliminator );
-                if ( eliminator.typedefNames.count( "size_t" ) ) {
+                if ( eliminator.pass.typedefNames.count( "size_t" ) ) {
                         // grab and remember declaration of size_t
-                        SizeType = eliminator.typedefNames["size_t"].first->get_base()->clone();
+                        SizeType = eliminator.pass.typedefNames["size_t"].first->get_base()->clone();
                 } else {
                         // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
@@ -681 +688 @@
         }
 
-        Type *EliminateTypedef::mutate( TypeInstType * typeInst ) {
+        Type * EliminateTypedef::postmutate( TypeInstType * typeInst ) {
                 // instances of typedef types will come here. If it is an instance
                 // of a typdef type, link the instance to its actual type.
@@ -696 +703 @@
                                 rtt->get_parameters().clear();
                                 cloneAll( typeInst->get_parameters(), rtt->get_parameters() );
-                                mutateAll( rtt->get_parameters(), *this );  // recursively fix typedefs on parameters
+                                mutateAll( rtt->get_parameters(), *visitor );  // recursively fix typedefs on parameters
                         } // if
                         delete typeInst;
@@ -708 +715 @@
         }
 
-        Declaration *EliminateTypedef::mutate( TypedefDecl * tyDecl ) {
-                Declaration *ret = Mutator::mutate( tyDecl );
-
+        Declaration *EliminateTypedef::postmutate( TypedefDecl * tyDecl ) {
                 if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
                         // typedef to the same name from the same scope
@@ -741 +746 @@
                         return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() );
                 } else {
-                        return ret->clone();
-                } // if
-        }
-
-        TypeDecl *EliminateTypedef::mutate( TypeDecl * typeDecl ) {
+                        return tyDecl->clone();
+                } // if
+        }
+
+        void EliminateTypedef::premutate( TypeDecl * typeDecl ) {
                 TypedefMap::iterator i = typedefNames.find( typeDecl->get_name() );
                 if ( i != typedefNames.end() ) {
@@ -752 +757 @@
 
                 typedeclNames[ typeDecl->get_name() ] = typeDecl;
-                return Mutator::mutate( typeDecl );
-        }
-
-        DeclarationWithType *EliminateTypedef::mutate( FunctionDecl * funcDecl ) {
-                typedefNames.beginScope();
-                DeclarationWithType *ret = Mutator::mutate( funcDecl );
-                typedefNames.endScope();
-                return ret;
-        }
-
-        DeclarationWithType *EliminateTypedef::mutate( ObjectDecl * objDecl ) {
-                typedefNames.beginScope();
-                DeclarationWithType *ret = Mutator::mutate( objDecl );
-                typedefNames.endScope();
-
-                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) { // function type?
+        }
+
+        void EliminateTypedef::premutate( FunctionDecl * ) {
+                GuardScope( typedefNames );
+        }
+
+        void EliminateTypedef::premutate( ObjectDecl * ) {
+                GuardScope( typedefNames );
+        }
+
+        DeclarationWithType *EliminateTypedef::postmutate( ObjectDecl * objDecl ) {
+                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->get_type() ) ) { // function type?
                         // replace the current object declaration with a function declaration
-                        FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClasses(), ret->get_linkage(), funtype, 0, objDecl->get_attributes(), ret->get_funcSpec() );
+                        FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() );
                         objDecl->get_attributes().clear();
                         objDecl->set_type( nullptr );
@@ -775 +776 @@
                         return newDecl;
                 } // if
-                return ret;
-        }
-
-        Expression *EliminateTypedef::mutate( CastExpr * castExpr ) {
-                typedefNames.beginScope();
-                Expression *ret = Mutator::mutate( castExpr );
-                typedefNames.endScope();
-                return ret;
-        }
-
-        CompoundStmt *EliminateTypedef::mutate( CompoundStmt * compoundStmt ) {
-                typedefNames.beginScope();
+                return objDecl;
+        }
+
+        void EliminateTypedef::premutate( CastExpr * ) {
+                GuardScope( typedefNames );
+        }
+
+        void EliminateTypedef::premutate( CompoundStmt * ) {
+                GuardScope( typedefNames );
                 scopeLevel += 1;
-                CompoundStmt *ret = Mutator::mutate( compoundStmt );
-                scopeLevel -= 1;
+                GuardAction( [this](){ scopeLevel -= 1; } );
+        }
+
+        CompoundStmt *EliminateTypedef::postmutate( CompoundStmt * compoundStmt ) {
                 // remove and delete decl stmts
                 filter( compoundStmt->kids, [](Statement * stmt) {
@@ -799 +799 @@
                         return false;
                 }, true);
-                typedefNames.endScope();
-                return ret;
+                return compoundStmt;
         }
 
@@ -827 +826 @@
         }
 
-        Declaration *EliminateTypedef::mutate( StructDecl * structDecl ) {
+        void EliminateTypedef::premutate( StructDecl * structDecl ) {
                 addImplicitTypedef( structDecl );
-                Mutator::mutate( structDecl );
+        }
+
+
+        Declaration *EliminateTypedef::postmutate( StructDecl * structDecl ) {
                 return handleAggregate( structDecl );
         }
 
-        Declaration *EliminateTypedef::mutate( UnionDecl * unionDecl ) {
+        void EliminateTypedef::premutate( UnionDecl * unionDecl ) {
                 addImplicitTypedef( unionDecl );
-                Mutator::mutate( unionDecl );
+        }
+
+        Declaration *EliminateTypedef::postmutate( UnionDecl * unionDecl ) {
                 return handleAggregate( unionDecl );
         }
 
-        Declaration *EliminateTypedef::mutate( EnumDecl * enumDecl ) {
+        void EliminateTypedef::premutate( EnumDecl * enumDecl ) {
                 addImplicitTypedef( enumDecl );
-                Mutator::mutate( enumDecl );
+        }
+
+        Declaration *EliminateTypedef::postmutate( EnumDecl * enumDecl ) {
                 return handleAggregate( enumDecl );
         }
 
-        Declaration *EliminateTypedef::mutate( TraitDecl * contextDecl ) {
-                Mutator::mutate( contextDecl );
-                return handleAggregate( contextDecl );
+        Declaration *EliminateTypedef::postmutate( TraitDecl * traitDecl ) {
+                return handleAggregate( traitDecl );
         }
 

src/SynTree/BasicType.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  1 17:12:15 2017
-// Update Count     : 8
+// Last Modified On : Mon Sep 11 12:52:05 2017
+// Update Count     : 9
 //
 
@@ -25 +25 @@
 
 void BasicType::print( std::ostream &os, int indent ) const {
-        static const char *kindNames[] = {      
-                "_Bool", "char", "signed char", "unsigned char", "short signed int", "short unsigned int",
-                "signed int", "unsigned int", "long signed int", "long unsigned int", "long long signed int",
-                "long long unsigned int", "float", "double", "long double", "float _Complex", "double _Complex",
-                "long double _Complex", "float _Imaginary", "double _Imaginary", "long double _Imaginary"
-        };
-
         Type::print( os, indent );
-        os << kindNames[ kind ];
+        os << BasicType::typeNames[ kind ];
 }
 

src/SynTree/Declaration.h

@@ -136 +136 @@
         Expression *get_bitfieldWidth() const { return bitfieldWidth; }
         void set_bitfieldWidth( Expression *newValue ) { bitfieldWidth = newValue; }
+
+        static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init );
 
         virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
@@ -230 +232 @@
         virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual TypeDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
 

src/SynTree/Mutator.cc

@@ -78 +78 @@
 }
 
-TypeDecl * Mutator::mutate( TypeDecl *typeDecl ) {
+Declaration * Mutator::mutate( TypeDecl *typeDecl ) {
         handleNamedTypeDecl( typeDecl );
         typeDecl->set_init( maybeMutate( typeDecl->get_init(), *this ) );

src/SynTree/Mutator.h

@@ -31 +31 @@
         virtual Declaration* mutate( EnumDecl *aggregateDecl );
         virtual Declaration* mutate( TraitDecl *aggregateDecl );
-        virtual TypeDecl* mutate( TypeDecl *typeDecl );
+        virtual Declaration* mutate( TypeDecl *typeDecl );
         virtual Declaration* mutate( TypedefDecl *typeDecl );
         virtual AsmDecl* mutate( AsmDecl *asmDecl );

src/SynTree/ObjectDecl.cc

@@ -38 +38 @@
         delete init;
         delete bitfieldWidth;
+}
+
+ObjectDecl * ObjectDecl::newObject( const std::string & name, Type * type, Initializer * init ) {
+        return new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
 }
 

src/SynTree/Statement.cc

@@ -472 +472 @@
 }
 
-NullStmt::NullStmt( std::list<Label> labels ) : CompoundStmt( labels ) {}
-NullStmt::NullStmt() : CompoundStmt( std::list<Label>() ) {}
+NullStmt::NullStmt( std::list<Label> labels ) : Statement( labels ) {}
+NullStmt::NullStmt() : Statement( std::list<Label>() ) {}
 
 void NullStmt::print( std::ostream &os, __attribute__((unused)) int indent ) const {

src/SynTree/Statement.h

@@ -67 +67 @@
 };
 
-class NullStmt : public CompoundStmt {
+class NullStmt : public Statement {
   public:
         NullStmt();

src/SynTree/Type.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Aug  2 11:11:00 2017
-// Update Count     : 29
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Sep 11 13:21:25 2017
+// Update Count     : 37
 //
 #include "Type.h"
@@ -26 +26 @@
         "_Bool",
         "char",
-        "char",
+        "signed char",
         "unsigned char",
-        "short",
-        "short unsigned",
-        "int",
+        "signed short int",
+        "unsigned short int",
+        "signed int",
         "unsigned int",
-        "long int",
-        "long unsigned int",
-        "long long int",
-        "long long unsigned int",
+        "signed long int",
+        "unsigned long int",
+        "signed long long int",
+        "unsigned long long int",
         "float",
         "double",
@@ -65 +65 @@
 
 Type * Type::stripDeclarator() {
-        Type * type = this;
-        while ( Type * at = InitTweak::getPointerBase( type ) ) {
-                type = at;
-        }
+        Type * type, * at;
+        for ( type = this; (at = InitTweak::getPointerBase( type )); type = at );
         return type;
 }
 
 Type * Type::stripReferences() {
-        Type * type = this;
-        while ( ReferenceType * ref = dynamic_cast<ReferenceType *>( type ) ) {
-                type = ref->get_base();
-        }
+        Type * type;
+        ReferenceType * ref;
+        for ( type = this; (ref = dynamic_cast<ReferenceType *>( type )); type = ref->get_base() );
         return type;
 }

src/libcfa/iostream

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 24 08:14:29 2017
-// Update Count     : 133
+// Last Modified On : Mon Sep 11 09:17:07 2017
+// Update Count     : 137
 //
 
 #pragma once
 
+#include <uchar.h>
+#include <wchar.h>
 #include "iterator"
 
@@ -78 +80 @@
 
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char * );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char16_t * );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char32_t * );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const wchar_t * );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const void * );
 
@@ -118 +123 @@
 
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, char & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, signed char & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned char & );
 
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, short int & );

src/libcfa/iostream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 24 08:41:53 2017
-// Update Count     : 405
+// Last Modified On : Mon Sep 11 09:21:24 2017
+// Update Count     : 420
 //
 
@@ -145 +145 @@
 
 forall( dtype ostype | ostream( ostype ) )
-ostype * ?|?( ostype * os, const char * cp ) {
+ostype * ?|?( ostype * os, const char * str ) {
         enum { Open = 1, Close, OpenClose };
         static const unsigned char mask[256] @= {
@@ -161 +161 @@
         }; // mask
 
-  if ( cp[0] == '\0' ) { sepOff( os ); return os; }             // null string => no separator
+  if ( str[0] == '\0' ) { sepOff( os ); return os; }            // null string => no separator
 
         // first character IS NOT spacing or closing punctuation => add left separator
-        unsigned char ch = cp[0];                                                       // must make unsigned
+        unsigned char ch = str[0];                                                      // must make unsigned
         if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
                 fmt( os, "%s", sepGetCur( os ) );
@@ -173 +173 @@
 
         // last character IS spacing or opening punctuation => turn off separator for next item
-        size_t len = strlen( cp );
-        ch = cp[len - 1];                                                                       // must make unsigned
+        size_t len = strlen( str );
+        ch = str[len - 1];                                                                      // must make unsigned
         if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
                 sepOn( os );
@@ -181 +181 @@
         } // if
         if ( ch == '\n' ) setNL( os, true );                            // check *AFTER* sepPrt call above as it resets NL flag
-        return write( os, cp, len );
+        return write( os, str, len );
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype * os, const char16_t * str ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+        fmt( os, "%ls", str );
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype * os, const char32_t * str ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+        fmt( os, "%ls", str );
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype * os, const wchar_t * str ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+        fmt( os, "%ls", str );
+        return os;
 } // ?|?
 
@@ -277 +298 @@
 
 forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, signed char & sc ) {
+        fmt( is, "%hhd", &sc );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned char & usc ) {
+        fmt( is, "%hhu", &usc );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, short int & si ) {
         fmt( is, "%hd", &si );

src/tests/.expect/32/KRfunctions.txt

@@ -2 +2 @@
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-int __f0__Fi_iPCii__1(int __a__i_1, const int *__b__PCi_1, int __c__i_1){
-    __attribute__ ((unused)) int ___retval_f0__i_1;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+signed int __f0__Fi_iPCii__1(signed int __a__i_1, const signed int *__b__PCi_1, signed int __c__i_1){
+    __attribute__ ((unused)) signed int ___retval_f0__i_1;
 }
-int __f1__Fi_PiiPi__1(int *__a__Pi_1, __attribute__ ((unused)) int __b__i_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int ___retval_f1__i_1;
+signed int __f1__Fi_PiiPi__1(signed int *__a__Pi_1, __attribute__ ((unused)) signed int __b__i_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_f1__i_1;
 }
-int __f2__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int ___retval_f2__i_1;
+signed int __f2__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_f2__i_1;
 }
 struct S {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
@@ -36 +36 @@
     return ((struct S )___ret__2sS_1);
 }
-static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __i__i_1){
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
     ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
 }
-int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int ___retval_f3__i_1;
+signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_f3__i_1;
     struct S __s__2sS_2;
 }
-int __f4__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int ___retval_f4__i_1;
+signed int __f4__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_f4__i_1;
 }
-int __f5__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int ___retval_f5__i_1;
+signed int __f5__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_f5__i_1;
 }
-int (*__f6__FPFi_i__iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))(int __anonymous_object0){
-    __attribute__ ((unused)) int (*___retval_f6__PFi_i__1)(int __anonymous_object1);
+signed int (*__f6__FPFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
+    __attribute__ ((unused)) signed int (*___retval_f6__PFi_i__1)(signed int __anonymous_object1);
 }
-int (*__f7__FPFi_ii__iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))(int __a__i_1, int __b__i_1){
-    __attribute__ ((unused)) int (*___retval_f7__PFi_ii__1)(int __a__i_1, int __b__i_1);
+signed int (*__f7__FPFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
+    __attribute__ ((unused)) signed int (*___retval_f7__PFi_ii__1)(signed int __a__i_1, signed int __b__i_1);
 }
-int *__f8__FPi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int *___retval_f8__Pi_1;
+signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int *___retval_f8__Pi_1;
 }
-int *const __f9__FCPi_PiiPi__1(int *__a__Pi_1, int __b__i_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int *const ___retval_f9__CPi_1;
+signed int *const __f9__FCPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1;
 }
-int *(*__f10__FPFPi_ii__iPiPid__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1, double __y__d_1))(int __x__i_1, int __y__i_1){
-    __attribute__ ((unused)) int *(*___retval_f10__PFPi_ii__1)(int __x__i_1, int __y__i_1);
-    int *__x__FPi_ii__2(int __anonymous_object2, int __anonymous_object3);
+signed int *(*__f10__FPFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
+    __attribute__ ((unused)) signed int *(*___retval_f10__PFPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
+    signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
     ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
-    return ((int *(*)(int __x__i_1, int __y__i_1))___retval_f10__PFPi_ii__1);
+    return ((signed int *(*)(signed int __x__i_1, signed int __y__i_1))___retval_f10__PFPi_ii__1);
 }
-int (*__f11__FPA0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[]{
-    __attribute__ ((unused)) int (*___retval_f11__PA0i_1)[];
+signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{
+    __attribute__ ((unused)) signed int (*___retval_f11__PA0i_1)[];
 }
-int (*__f12__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((unsigned int )10)]{
-    __attribute__ ((unused)) int (*___retval_f12__PA0A0i_1)[][((unsigned int )10)];
+signed int (*__f12__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{
+    __attribute__ ((unused)) signed int (*___retval_f12__PA0A0i_1)[][((unsigned int )10)];
 }
-int (*__f13__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((unsigned int )10)]{
-    __attribute__ ((unused)) int (*___retval_f13__PA0A0i_1)[][((unsigned int )10)];
+signed int (*__f13__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{
+    __attribute__ ((unused)) signed int (*___retval_f13__PA0A0i_1)[][((unsigned int )10)];
 }
-int (*__f14__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((unsigned int )10)]{
-    __attribute__ ((unused)) int (*___retval_f14__PA0A0i_1)[][((unsigned int )10)];
+signed int (*__f14__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{
+    __attribute__ ((unused)) signed int (*___retval_f14__PA0A0i_1)[][((unsigned int )10)];
 }
-int __f15__Fi_iii__1(int __a__i_1, int __b__i_1, int __c__i_1){
-    __attribute__ ((unused)) int ___retval_f15__i_1;
+signed int __f15__Fi_iii__1(signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
+    __attribute__ ((unused)) signed int ___retval_f15__i_1;
 }
-const int __fred__FCi___1(){
-    __attribute__ ((unused)) const int ___retval_fred__Ci_1;
-    int *(*__x__PFPi_ii__2)(int __anonymous_object4, int __anonymous_object5);
-    int __a__i_2;
-    int __b__i_2;
-    int *(*_tmp_cp_ret0)(int __x__i_1, int __y__i_1);
+const signed int __fred__FCi___1(){
+    __attribute__ ((unused)) const signed int ___retval_fred__Ci_1;
+    signed int *(*__x__PFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
+    signed int __a__i_2;
+    signed int __b__i_2;
+    signed int *(*_tmp_cp_ret0)(signed int __x__i_1, signed int __y__i_1);
     ((void)(__x__PFPi_ii__2=(((void)(_tmp_cp_ret0=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret0)));
     ((void)(_tmp_cp_ret0) /* ^?{} */);
-    const int __f1__FCi_iPiPi__2(int __a__i_2, int *__b__Pi_2, int *__c__Pi_2){
-        __attribute__ ((unused)) const int ___retval_f1__Ci_2;
+    const signed int __f1__FCi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
+        __attribute__ ((unused)) const signed int ___retval_f1__Ci_2;
     }
-    const int __f2__FCi_iii__2(int __a__i_2, int __b__i_2, int __c__i_2){
-        __attribute__ ((unused)) const int ___retval_f2__Ci_2;
+    const signed int __f2__FCi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+        __attribute__ ((unused)) const signed int ___retval_f2__Ci_2;
     }
 }

src/tests/.expect/32/attributes.txt

@@ -2 +2 @@
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-int __la__Fi___1(){
-    __attribute__ ((unused)) int ___retval_la__i_1;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+signed int __la__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_la__i_1;
     L: __attribute__ ((unused)) ((void)1);
 }
@@ -54 +54 @@
 __attribute__ ((unused)) struct __anonymous3;
 struct Fdl {
-    __attribute__ ((unused)) int __f1__i_1;
-    __attribute__ ((unused)) int __f2__i_1;
-    __attribute__ ((unused,unused)) int __f3__i_1;
-    __attribute__ ((unused)) int __f4__i_1;
-    __attribute__ ((unused,unused)) int __f5__i_1;
-    __attribute__ ((used,packed)) int __f6__i_1;
-    __attribute__ ((used,unused,unused)) int __f7__i_1;
-    __attribute__ ((used,used,unused)) int __f8__i_1;
-    __attribute__ ((unused)) int __anonymous_object0;
-    __attribute__ ((unused,unused)) int *__f9__Pi_1;
+    __attribute__ ((unused)) signed int __f1__i_1;
+    __attribute__ ((unused)) signed int __f2__i_1;
+    __attribute__ ((unused,unused)) signed int __f3__i_1;
+    __attribute__ ((unused)) signed int __f4__i_1;
+    __attribute__ ((unused,unused)) signed int __f5__i_1;
+    __attribute__ ((used,packed)) signed int __f6__i_1;
+    __attribute__ ((used,unused,unused)) signed int __f7__i_1;
+    __attribute__ ((used,used,unused)) signed int __f8__i_1;
+    __attribute__ ((unused)) signed int __anonymous_object0;
+    __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
 };
 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
@@ -116 +116 @@
     return ((struct Fdl )___ret__4sFdl_1);
 }
-static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1){
+static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */);
@@ -127 +127 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1){
+static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -138 +138 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1){
+static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -149 +149 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1){
-    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
-}
-static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1){
-    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
-}
-static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1){
+static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1){
+    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1){
+    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -182 +182 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1){
+static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -193 +193 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1){
+static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -204 +204 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1, int *__f9__Pi_1){
+static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int *__f9__Pi_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -215 +215 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
 }
-__attribute__ ((unused)) int __f__Fi___1() asm ( "xyz" );
-__attribute__ ((used,used)) const int __vd1__Ci_1;
-__attribute__ ((used,unused)) const int __vd2__Ci_1;
-__attribute__ ((used,used,used,used)) const int *__vd3__PCi_1;
-__attribute__ ((used,used,unused,used,unused)) const int *__vd4__PCi_1;
-__attribute__ ((used,used,used)) const int __vd5__A0Ci_1[((unsigned int )5)];
-__attribute__ ((used,used,unused,used)) const int __vd6__A0Ci_1[((unsigned int )5)];
-__attribute__ ((used,used,used,used)) const int (*__vd7__PFCi___1)();
-__attribute__ ((used,used,unused,used,used)) const int (*__vd8__PFCi___1)();
-__attribute__ ((unused,used)) int __f1__Fi___1();
-__attribute__ ((unused)) int __f1__Fi___1(){
-    __attribute__ ((unused)) int ___retval_f1__i_1;
-}
-__attribute__ ((unused,unused,unused,used)) int **const __f2__FCPPi___1();
-__attribute__ ((unused,unused,unused)) int **const __f2__FCPPi___1(){
-    __attribute__ ((unused)) int **const ___retval_f2__CPPi_1;
-}
-__attribute__ ((unused,used,unused)) int (*__f3__FPA0i_i__1(int __anonymous_object1))[];
-__attribute__ ((unused,unused)) int (*__f3__FPA0i_i__1(int __p__i_1))[]{
-    __attribute__ ((unused)) int (*___retval_f3__PA0i_1)[];
-}
-__attribute__ ((unused,used,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object2);
-__attribute__ ((unused,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object3){
-    __attribute__ ((unused)) int (*___retval_f4__PFi_i__1)(int __anonymous_object4);
-}
-int __vtr__Fi___1(){
-    __attribute__ ((unused)) int ___retval_vtr__i_1;
-    __attribute__ ((unused,unused,used)) int __t1__i_2;
-    __attribute__ ((unused,unused,unused,unused,unused)) int **__t2__PPi_2;
-    __attribute__ ((unused,unused,unused)) int __t3__A0i_2[((unsigned int )5)];
-    __attribute__ ((unused,unused,unused,unused,unused)) int **__t4__A0PPi_2[((unsigned int )5)];
-    __attribute__ ((unused,unused,unused)) int __t5__Fi___2();
-    __attribute__ ((unused,unused,unused,unused)) int *__t6__FPi___2();
-}
-int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1);
-int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1){
-    __attribute__ ((unused)) int ___retval_ipd1__i_1;
-}
-int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
-int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
-    __attribute__ ((unused)) int ___retval_ipd2__i_1;
-}
-int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
-int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
-    __attribute__ ((unused)) int ___retval_ipd3__i_1;
-}
-int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)());
-int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)()){
-    __attribute__ ((unused)) int ___retval_ipd4__i_1;
-}
-int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) int __Foo__i_1);
-int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) int **__Foo__PPi_1);
-int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) int *__Foo__Pi_1);
-int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) int (*__anonymous_object5)(__attribute__ ((unused,unused)) int __anonymous_object6[((unsigned int )5)]));
-int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) int (*__Foo__PFi___1)());
-int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) int (*__Foo__PFi___1)());
-int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) int (*__anonymous_object7)(__attribute__ ((unused)) int (*__anonymous_object8)(__attribute__ ((unused,unused)) int __anonymous_object9)));
-int __ad__Fi___1(){
-    __attribute__ ((unused)) int ___retval_ad__i_1;
-    __attribute__ ((used,unused)) int __ad1__i_2;
-    __attribute__ ((unused,unused,unused)) int *__ad2__Pi_2;
-    __attribute__ ((unused,unused,unused)) int __ad3__A0i_2[((unsigned int )5)];
-    __attribute__ ((unused,unused,unused,unused,unused)) int (*__ad4__PA0i_2)[((unsigned int )10)];
-    __attribute__ ((unused,unused,unused,unused,used)) int __ad5__i_2;
-    __attribute__ ((unused,unused,unused,unused,unused)) int __ad6__Fi___2();
-    ((void)sizeof(__attribute__ ((unused,unused)) int ));
-    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) int **));
-    ((void)sizeof(__attribute__ ((unused,unused,unused)) int [5]));
-    ((void)sizeof(__attribute__ ((unused,unused,unused)) int (*)[10]));
-    ((void)sizeof(__attribute__ ((unused,unused,unused)) int ()));
+__attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
+__attribute__ ((used,used)) const signed int __vd1__Ci_1;
+__attribute__ ((used,unused)) const signed int __vd2__Ci_1;
+__attribute__ ((used,used,used,used)) const signed int *__vd3__PCi_1;
+__attribute__ ((used,used,unused,used,unused)) const signed int *__vd4__PCi_1;
+__attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned int )5)];
+__attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned int )5)];
+__attribute__ ((used,used,used,used)) const signed int (*__vd7__PFCi___1)();
+__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__PFCi___1)();
+__attribute__ ((unused,used)) signed int __f1__Fi___1();
+__attribute__ ((unused)) signed int __f1__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_f1__i_1;
+}
+__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FCPPi___1();
+__attribute__ ((unused,unused,unused)) signed int **const __f2__FCPPi___1(){
+    __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
+}
+__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object1))[];
+__attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
+    __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object2);
+__attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object3){
+    __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object4);
+}
+signed int __vtr__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_vtr__i_1;
+    __attribute__ ((unused,unused,used)) signed int __t1__i_2;
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t2__PPi_2;
+    __attribute__ ((unused,unused,unused)) signed int __t3__A0i_2[((unsigned int )5)];
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t4__A0PPi_2[((unsigned int )5)];
+    __attribute__ ((unused,unused,unused)) signed int __t5__Fi___2();
+    __attribute__ ((unused,unused,unused,unused)) signed int *__t6__FPi___2();
+}
+signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1);
+signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1){
+    __attribute__ ((unused)) signed int ___retval_ipd1__i_1;
+}
+signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
+signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_ipd2__i_1;
+}
+signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
+signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
+}
+signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)());
+signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)()){
+    __attribute__ ((unused)) signed int ___retval_ipd4__i_1;
+}
+signed int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) signed int __Foo__i_1);
+signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
+signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
+signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object5)(__attribute__ ((unused,unused)) signed int __anonymous_object6[((unsigned int )5)]));
+signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
+signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
+signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object7)(__attribute__ ((unused)) signed int (*__anonymous_object8)(__attribute__ ((unused,unused)) signed int __anonymous_object9)));
+signed int __ad__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_ad__i_1;
+    __attribute__ ((used,unused)) signed int __ad1__i_2;
+    __attribute__ ((unused,unused,unused)) signed int *__ad2__Pi_2;
+    __attribute__ ((unused,unused,unused)) signed int __ad3__A0i_2[((unsigned int )5)];
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*__ad4__PA0i_2)[((unsigned int )10)];
+    __attribute__ ((unused,unused,unused,unused,used)) signed int __ad5__i_2;
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int __ad6__Fi___2();
+    ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
+    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
+    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [5]));
+    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[10]));
+    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
     __attribute__ ((unused)) struct __anonymous4 {
-        int __i__i_2;
+        signed int __i__i_2;
     };
     inline void ___constructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
@@ -303 +303 @@
         return ((struct __anonymous4 )___ret__13s__anonymous4_2);
     }
-    inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, int __i__i_2){
+    inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
     }
@@ -324 +324 @@
     ((void)sizeof(enum __anonymous5 ));
 }
-int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object10, __attribute__ ((unused,unused,unused)) int *__anonymous_object11);
-int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) int **__anonymous_object13);
-int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object14, __attribute__ ((unused,unused,unused)) int *__anonymous_object15);
-int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) int (*__anonymous_object17)());
-int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object18)(__attribute__ ((unused)) int __anonymous_object19), __attribute__ ((unused,unused,unused)) int (*__anonymous_object20)(__attribute__ ((unused)) int __anonymous_object21));
-int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) int (*__anonymous_object23)());
-int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object24)(__attribute__ ((unused)) int __anonymous_object25), __attribute__ ((unused,unused,unused)) int (*__anonymous_object26)(__attribute__ ((unused)) int __anonymous_object27));
+signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object10, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object11);
+signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object13);
+signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
+signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)());
+signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object18)(__attribute__ ((unused)) signed int __anonymous_object19), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(__attribute__ ((unused)) signed int __anonymous_object21));
+signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)());
+signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(__attribute__ ((unused)) signed int __anonymous_object27));
 struct Vad {
-    __attribute__ ((unused)) int __anonymous_object28;
-    __attribute__ ((unused,unused)) int *__anonymous_object29;
-    __attribute__ ((unused,unused)) int __anonymous_object30[((unsigned int )10)];
-    __attribute__ ((unused,unused)) int (*__anonymous_object31)();
+    __attribute__ ((unused)) signed int __anonymous_object28;
+    __attribute__ ((unused,unused)) signed int *__anonymous_object29;
+    __attribute__ ((unused,unused)) signed int __anonymous_object30[((unsigned int )10)];
+    __attribute__ ((unused,unused)) signed int (*__anonymous_object31)();
 };
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);

src/tests/.expect/32/declarationSpecifier.txt

@@ -2 +2 @@
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-volatile const short __x1__CVs_1;
-static volatile const short __x2__CVs_1;
-static volatile const short __x3__CVs_1;
-static volatile const short __x4__CVs_1;
-static volatile const short __x5__CVs_1;
-static volatile const short __x6__CVs_1;
-static volatile const short __x7__CVs_1;
-static volatile const short __x8__CVs_1;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+volatile const signed short int __x1__CVs_1;
+static volatile const signed short int __x2__CVs_1;
+static volatile const signed short int __x3__CVs_1;
+static volatile const signed short int __x4__CVs_1;
+static volatile const signed short int __x5__CVs_1;
+static volatile const signed short int __x6__CVs_1;
+static volatile const signed short int __x7__CVs_1;
+static volatile const signed short int __x8__CVs_1;
 struct __anonymous0 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
@@ -35 +35 @@
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
 }
-static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
 struct __anonymous1 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
@@ -61 +61 @@
     return ((struct __anonymous1 )___ret__13s__anonymous1_1);
 }
-static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
 struct __anonymous2 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
@@ -87 +87 @@
     return ((struct __anonymous2 )___ret__13s__anonymous2_1);
 }
-static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
 struct __anonymous3 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
@@ -113 +113 @@
     return ((struct __anonymous3 )___ret__13s__anonymous3_1);
 }
-static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
 struct __anonymous4 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
@@ -139 +139 @@
     return ((struct __anonymous4 )___ret__13s__anonymous4_1);
 }
-static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
 struct __anonymous5 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
@@ -165 +165 @@
     return ((struct __anonymous5 )___ret__13s__anonymous5_1);
 }
-static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
 struct __anonymous6 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
@@ -191 +191 @@
     return ((struct __anonymous6 )___ret__13s__anonymous6_1);
 }
-static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
 struct __anonymous7 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
@@ -217 +217 @@
     return ((struct __anonymous7 )___ret__13s__anonymous7_1);
 }
-static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
-volatile const short __x20__CVs_1;
-static volatile const short __x21__CVs_1;
-static volatile const short __x22__CVs_1;
-static volatile const short __x23__CVs_1;
-static volatile const short __x24__CVs_1;
-static volatile const short __x25__CVs_1;
-static volatile const short __x26__CVs_1;
-static volatile const short __x27__CVs_1;
+volatile const signed short int __x20__CVs_1;
+static volatile const signed short int __x21__CVs_1;
+static volatile const signed short int __x22__CVs_1;
+static volatile const signed short int __x23__CVs_1;
+static volatile const signed short int __x24__CVs_1;
+static volatile const signed short int __x25__CVs_1;
+static volatile const signed short int __x26__CVs_1;
+static volatile const signed short int __x27__CVs_1;
 struct __anonymous8 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
@@ -251 +251 @@
     return ((struct __anonymous8 )___ret__13s__anonymous8_1);
 }
-static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, short __i__s_1){
+static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
 struct __anonymous9 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
@@ -277 +277 @@
     return ((struct __anonymous9 )___ret__13s__anonymous9_1);
 }
-static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, short __i__s_1){
+static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
 struct __anonymous10 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
@@ -303 +303 @@
     return ((struct __anonymous10 )___ret__14s__anonymous10_1);
 }
-static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
 struct __anonymous11 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
@@ -329 +329 @@
     return ((struct __anonymous11 )___ret__14s__anonymous11_1);
 }
-static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
 struct __anonymous12 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
@@ -355 +355 @@
     return ((struct __anonymous12 )___ret__14s__anonymous12_1);
 }
-static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
 struct __anonymous13 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
@@ -381 +381 @@
     return ((struct __anonymous13 )___ret__14s__anonymous13_1);
 }
-static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
 struct __anonymous14 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
@@ -407 +407 @@
     return ((struct __anonymous14 )___ret__14s__anonymous14_1);
 }
-static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1;
 struct __anonymous15 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1);
@@ -433 +433 @@
     return ((struct __anonymous15 )___ret__14s__anonymous15_1);
 }
-static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1;
-static inline volatile const int __f11__FCVi___1();
-static inline volatile const int __f12__FCVi___1();
-static inline volatile const int __f13__FCVi___1();
-static inline volatile const int __f14__FCVi___1();
-static inline volatile const int __f15__FCVi___1();
-static inline volatile const int __f16__FCVi___1();
-static inline volatile const int __f17__FCVi___1();
-static inline volatile const int __f18__FCVi___1();
-static inline volatile const short __f21__FCVs___1();
-static inline volatile const short __f22__FCVs___1();
-static inline volatile const short __f23__FCVs___1();
-static inline volatile const short __f24__FCVs___1();
-static inline volatile const short __f25__FCVs___1();
-static inline volatile const short __f26__FCVs___1();
-static inline volatile const short __f27__FCVs___1();
-static inline volatile const short __f28__FCVs___1();
+static inline volatile const signed int __f11__FCVi___1();
+static inline volatile const signed int __f12__FCVi___1();
+static inline volatile const signed int __f13__FCVi___1();
+static inline volatile const signed int __f14__FCVi___1();
+static inline volatile const signed int __f15__FCVi___1();
+static inline volatile const signed int __f16__FCVi___1();
+static inline volatile const signed int __f17__FCVi___1();
+static inline volatile const signed int __f18__FCVi___1();
+static inline volatile const signed short int __f21__FCVs___1();
+static inline volatile const signed short int __f22__FCVs___1();
+static inline volatile const signed short int __f23__FCVs___1();
+static inline volatile const signed short int __f24__FCVs___1();
+static inline volatile const signed short int __f25__FCVs___1();
+static inline volatile const signed short int __f26__FCVs___1();
+static inline volatile const signed short int __f27__FCVs___1();
+static inline volatile const signed short int __f28__FCVs___1();
 struct __anonymous16 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1);
@@ -475 +475 @@
     return ((struct __anonymous16 )___ret__14s__anonymous16_1);
 }
-static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous16 __f31__FCV14s__anonymous16___1();
 struct __anonymous17 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1);
@@ -501 +501 @@
     return ((struct __anonymous17 )___ret__14s__anonymous17_1);
 }
-static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous17 __f32__FCV14s__anonymous17___1();
 struct __anonymous18 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1);
@@ -527 +527 @@
     return ((struct __anonymous18 )___ret__14s__anonymous18_1);
 }
-static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous18 __f33__FCV14s__anonymous18___1();
 struct __anonymous19 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1);
@@ -553 +553 @@
     return ((struct __anonymous19 )___ret__14s__anonymous19_1);
 }
-static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous19 __f34__FCV14s__anonymous19___1();
 struct __anonymous20 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1);
@@ -579 +579 @@
     return ((struct __anonymous20 )___ret__14s__anonymous20_1);
 }
-static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous20 __f35__FCV14s__anonymous20___1();
 struct __anonymous21 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1);
@@ -605 +605 @@
     return ((struct __anonymous21 )___ret__14s__anonymous21_1);
 }
-static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous21 __f36__FCV14s__anonymous21___1();
 struct __anonymous22 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1);
@@ -631 +631 @@
     return ((struct __anonymous22 )___ret__14s__anonymous22_1);
 }
-static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous22 __f37__FCV14s__anonymous22___1();
 struct __anonymous23 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1);
@@ -657 +657 @@
     return ((struct __anonymous23 )___ret__14s__anonymous23_1);
 }
-static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous23 __f38__FCV14s__anonymous23___1();
-static inline volatile const short __f41__FCVs___1();
-static inline volatile const short __f42__FCVs___1();
-static inline volatile const short __f43__FCVs___1();
-static inline volatile const short __f44__FCVs___1();
-static inline volatile const short __f45__FCVs___1();
-static inline volatile const short __f46__FCVs___1();
-static inline volatile const short __f47__FCVs___1();
-static inline volatile const short __f48__FCVs___1();
-int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
-    __attribute__ ((unused)) int ___retval_main__i_1;
-    ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
-    return ((int )___retval_main__i_1);
+static inline volatile const signed short int __f41__FCVs___1();
+static inline volatile const signed short int __f42__FCVs___1();
+static inline volatile const signed short int __f43__FCVs___1();
+static inline volatile const signed short int __f44__FCVs___1();
+static inline volatile const signed short int __f45__FCVs___1();
+static inline volatile const signed short int __f46__FCVs___1();
+static inline volatile const signed short int __f47__FCVs___1();
+static inline volatile const signed short int __f48__FCVs___1();
+signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
+    __attribute__ ((unused)) signed int ___retval_main__i_1;
+    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
+    return ((signed int )___retval_main__i_1);
     ((void)(___retval_main__i_1=0) /* ?{} */);
-    return ((int )___retval_main__i_1);
+    return ((signed int )___retval_main__i_1);
 }
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
@@ -680 +680 @@
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-static inline int invoke_main(int argc, char **argv, char **envp);
-int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
-    __attribute__ ((unused)) int ___retval_main__i_1;
-    int _tmp_cp_ret0;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+static inline signed int invoke_main(signed int argc, char **argv, char **envp);
+signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
+    __attribute__ ((unused)) signed int ___retval_main__i_1;
+    signed int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
-    return ((int )___retval_main__i_1);
-}
+    return ((signed int )___retval_main__i_1);
+}

src/tests/.expect/32/extension.txt

@@ -2 +2 @@
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-__extension__ int __a__i_1;
-__extension__ int __b__i_1;
-__extension__ int __c__i_1;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+__extension__ signed int __a__i_1;
+__extension__ signed int __b__i_1;
+__extension__ signed int __c__i_1;
 __extension__ struct S {
-    __extension__ int __a__i_1;
-    __extension__ int __b__i_1;
-    __extension__ int __c__i_1;
+    __extension__ signed int __a__i_1;
+    __extension__ signed int __b__i_1;
+    __extension__ signed int __c__i_1;
 };
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
@@ -40 +40 @@
     return ((struct S )___ret__2sS_1);
 }
-static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __a__i_1){
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
 }
-static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1){
+static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
 }
-static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1, int __c__i_1){
+static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
@@ -56 +56 @@
 }
 __extension__ union U {
-    __extension__ int __a__i_1;
-    __extension__ int __b__i_1;
-    __extension__ int __c__i_1;
+    __extension__ signed int __a__i_1;
+    __extension__ signed int __b__i_1;
+    __extension__ signed int __c__i_1;
 };
 static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
@@ -73 +73 @@
     return ((union U )___ret__2uU_1);
 }
-static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, int __src__i_1){
-    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(int )));
+static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, signed int __src__i_1){
+    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(signed int )));
 }
 __extension__ enum E {
@@ -81 +81 @@
     __B__C2eE_1,
 };
-__extension__ int __f__Fi___1();
-__extension__ int i;
-__extension__ int j;
-__extension__ int __fred__Fi_i__1(int __p__i_1){
-    __attribute__ ((unused)) int ___retval_fred__i_1;
+__extension__ signed int __f__Fi___1();
+__extension__ signed int i;
+__extension__ signed int j;
+__extension__ signed int __fred__Fi_i__1(signed int __p__i_1){
+    __attribute__ ((unused)) signed int ___retval_fred__i_1;
     __extension__ struct S {
-        __extension__ int __a__i_2;
-        __extension__ int __b__i_2;
-        __extension__ int __c__i_2;
-        __extension__ int *__x__Pi_2;
-        __extension__ int *__y__Pi_2;
-        __extension__ int *__z__Pi_2;
+        __extension__ signed int __a__i_2;
+        __extension__ signed int __b__i_2;
+        __extension__ signed int __c__i_2;
+        __extension__ signed int *__x__Pi_2;
+        __extension__ signed int *__y__Pi_2;
+        __extension__ signed int *__z__Pi_2;
     };
-    int __i__i_2 = ((int )(__extension__ __a__i_1+__extension__ 3));
+    signed int __i__i_2 = ((signed int )(__extension__ __a__i_1+__extension__ 3));
     ((void)__extension__ 3);
     ((void)__extension__ __a__i_1);
-    __extension__ int __a__i_2;
-    __extension__ int __b__i_2;
-    __extension__ int __c__i_2;
+    __extension__ signed int __a__i_2;
+    __extension__ signed int __b__i_2;
+    __extension__ signed int __c__i_2;
     ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
-    int _tmp_cp_ret0;
+    signed int _tmp_cp_ret0;
     ((void)(((void)(_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3))) , _tmp_cp_ret0));
     ((void)(_tmp_cp_ret0) /* ^?{} */);
-    __extension__ int __mary__Fi_i__2(int __p__i_2){
-        __attribute__ ((unused)) int ___retval_mary__i_2;
+    __extension__ signed int __mary__Fi_i__2(signed int __p__i_2){
+        __attribute__ ((unused)) signed int ___retval_mary__i_2;
     }
     ((void)__extension__ sizeof(3));
-    ((void)__extension__ (((int )(3!=((int )0))) || ((int )(4!=((int )0)))));
+    ((void)__extension__ (((signed int )(3!=((signed int )0))) || ((signed int )(4!=((signed int )0)))));
     ((void)__extension__ __alignof__(__extension__ __a__i_2));
-    ((void)(((int )(__extension__ __a__i_2!=((int )0))) || ((int )((((int )(__extension__ __b__i_2!=((int )0))) && ((int )(__extension__ __c__i_2!=((int )0))))!=((int )0)))));
-    ((void)(((int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
+    ((void)(((signed int )(__extension__ __a__i_2!=((signed int )0))) || ((signed int )((((signed int )(__extension__ __b__i_2!=((signed int )0))) && ((signed int )(__extension__ __c__i_2!=((signed int )0))))!=((signed int )0)))));
+    ((void)(((signed int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
     ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
     ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));

src/tests/.expect/32/gccExtensions.txt

@@ -2 +2 @@
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-extern int __x__i_1 asm ( "xx" );
-int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
-    __attribute__ ((unused)) int ___retval_main__i_1;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+extern signed int __x__i_1 asm ( "xx" );
+signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
+    __attribute__ ((unused)) signed int ___retval_main__i_1;
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
-    static int __y__i_2 asm ( "yy" );
-    static int *__z__Pi_2 asm ( "zz" );
-    int __src__i_2;
-    int __dst__i_2;
-    asm volatile ( "mov %1, %0\n\tadd $1, %0" :  :  :  );
-    asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) :  :  );
-    asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
-    asm ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
+    static signed int __y__i_2 asm ( "yy" );
+    static signed int *__z__Pi_2 asm ( "zz" );
+    signed int __src__i_2;
+    signed int __dst__i_2;
+    asm volatile ( "mov %1, %0\n\t" "add $1, %0" :  :  :  );
+    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( __dst__i_2 ) :  :  );
+    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
+    asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
     L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" :  : "r" ( __src__i_2 ), "r" ( (&__dst__i_2) ) : "r5", "memory" : L1, L2 );
     double _Complex __c1__Xd_2;
     double _Complex __c2__Xd_2;
-    const int __i1__Ci_2;
-    const int __i2__Ci_2;
-    const int __i3__Ci_2;
-    inline int __f1__Fi___2(){
-        __attribute__ ((unused)) int ___retval_f1__i_2;
+    const signed int __i1__Ci_2;
+    const signed int __i2__Ci_2;
+    const signed int __i3__Ci_2;
+    inline signed int __f1__Fi___2(){
+        __attribute__ ((unused)) signed int ___retval_f1__i_2;
     }
-    inline int __f2__Fi___2(){
-        __attribute__ ((unused)) int ___retval_f2__i_2;
+    inline signed int __f2__Fi___2(){
+        __attribute__ ((unused)) signed int ___retval_f2__i_2;
     }
-    int __s1__i_2;
-    int __s2__i_2;
-    volatile int __v1__Vi_2;
-    volatile int __v2__Vi_2;
-    int __t1___2;
-    int __t2___2;
-    __extension__ const int __ex__Ci_2;
+    signed int __s1__i_2;
+    signed int __s2__i_2;
+    volatile signed int __v1__Vi_2;
+    volatile signed int __v2__Vi_2;
+    signed int __t1___2;
+    signed int __t2___2;
+    __extension__ const signed int __ex__Ci_2;
     struct S {
-        __extension__ int __a__i_2;
-        __extension__ int __b__i_2;
-        __extension__ int __c__i_2;
+        __extension__ signed int __a__i_2;
+        __extension__ signed int __b__i_2;
+        __extension__ signed int __c__i_2;
     };
     inline void ___constructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
@@ -66 +66 @@
         return ((struct S )___ret__2sS_2);
     }
-    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, int __a__i_2){
+    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
         ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
     }
-    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2){
+    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2){
         ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
     }
-    inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2, int __c__i_2){
+    inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
         ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
     }
-    int __i__i_2 = ((int )__extension__ 3);
-    __extension__ int __a__i_2;
-    __extension__ int __b__i_2;
-    __extension__ int __c__i_2;
+    signed int __i__i_2 = ((signed int )__extension__ 3);
+    __extension__ signed int __a__i_2;
+    __extension__ signed int __b__i_2;
+    __extension__ signed int __c__i_2;
     ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
     ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
     ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
-    int __a1__i_2;
-    const int __a2__Ci_2;
-    static const int __a3__Ci_2;
-    static const int __a4__Ci_2;
-    static const int __a5__Ci_2;
-    static const int __a6__Ci_2;
-    static const int __a7__Ci_2;
-    int *__p1__Pi_2;
-    int *__p2__Pi_2;
+    signed int __a1__i_2;
+    const signed int __a2__Ci_2;
+    static const signed int __a3__Ci_2;
+    static const signed int __a4__Ci_2;
+    static const signed int __a5__Ci_2;
+    static const signed int __a6__Ci_2;
+    static const signed int __a7__Ci_2;
+    signed int *__p1__Pi_2;
+    signed int *__p2__Pi_2;
     struct s1;
     struct s2 {
-        int __i__i_2;
+        signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){
@@ -116 +116 @@
         return ((struct s2 )___ret__3ss2_2);
     }
-    inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, int __i__i_2){
+    inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
         ((void)((*___dst__R3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
     }
     struct s3 {
-        int __i__i_2;
+        signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){
@@ -137 +137 @@
         return ((struct s3 )___ret__3ss3_2);
     }
-    inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, int __i__i_2){
+    inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
         ((void)((*___dst__R3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
     }
@@ -143 +143 @@
     struct s3 __y1__3ss3_2;
     struct s4 {
-        int __i__i_2;
+        signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){
@@ -160 +160 @@
         return ((struct s4 )___ret__3ss4_2);
     }
-    inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, int __i__i_2){
+    inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
         ((void)((*___dst__R3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
     }
     struct s4 __x2__3ss4_2;
     struct s4 __y2__3ss4_2;
-    int __m1__A0i_2[((unsigned int )10)];
-    int __m2__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
-    int __m3__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
-    ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
-    return ((int )___retval_main__i_1);
+    signed int __m1__A0i_2[((unsigned int )10)];
+    signed int __m2__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
+    signed int __m3__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
+    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
+    return ((signed int )___retval_main__i_1);
     ((void)(___retval_main__i_1=0) /* ?{} */);
-    return ((int )___retval_main__i_1);
+    return ((signed int )___retval_main__i_1);
 }
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
@@ -177 +177 @@
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-static inline int invoke_main(int argc, char **argv, char **envp);
-int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
-    __attribute__ ((unused)) int ___retval_main__i_1;
-    int _tmp_cp_ret0;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+static inline signed int invoke_main(signed int argc, char **argv, char **envp);
+signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
+    __attribute__ ((unused)) signed int ___retval_main__i_1;
+    signed int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
-    return ((int )___retval_main__i_1);
+    return ((signed int )___retval_main__i_1);
 }

src/tests/.expect/64/KRfunctions.txt

@@ -1 @@
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
+__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-int __f0__Fi_iPCii__1(int __a__i_1, const int *__b__PCi_1, int __c__i_1){
-    __attribute__ ((unused)) int ___retval_f0__i_1;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+signed int __f0__Fi_iPCii__1(signed int __a__i_1, const signed int *__b__PCi_1, signed int __c__i_1){
+    __attribute__ ((unused)) signed int ___retval_f0__i_1;
 }
-int __f1__Fi_PiiPi__1(int *__a__Pi_1, __attribute__ ((unused)) int __b__i_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int ___retval_f1__i_1;
+signed int __f1__Fi_PiiPi__1(signed int *__a__Pi_1, __attribute__ ((unused)) signed int __b__i_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_f1__i_1;
 }
-int __f2__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int ___retval_f2__i_1;
+signed int __f2__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_f2__i_1;
 }
 struct S {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
@@ -36 +36 @@
     return ((struct S )___ret__2sS_1);
 }
-static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __i__i_1){
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
     ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
 }
-int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int ___retval_f3__i_1;
+signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_f3__i_1;
     struct S __s__2sS_2;
 }
-int __f4__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int ___retval_f4__i_1;
+signed int __f4__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_f4__i_1;
 }
-int __f5__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int ___retval_f5__i_1;
+signed int __f5__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_f5__i_1;
 }
-int (*__f6__FPFi_i__iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))(int __anonymous_object0){
-    __attribute__ ((unused)) int (*___retval_f6__PFi_i__1)(int __anonymous_object1);
+signed int (*__f6__FPFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
+    __attribute__ ((unused)) signed int (*___retval_f6__PFi_i__1)(signed int __anonymous_object1);
 }
-int (*__f7__FPFi_ii__iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))(int __a__i_1, int __b__i_1){
-    __attribute__ ((unused)) int (*___retval_f7__PFi_ii__1)(int __a__i_1, int __b__i_1);
+signed int (*__f7__FPFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
+    __attribute__ ((unused)) signed int (*___retval_f7__PFi_ii__1)(signed int __a__i_1, signed int __b__i_1);
 }
-int *__f8__FPi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int *___retval_f8__Pi_1;
+signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int *___retval_f8__Pi_1;
 }
-int *const __f9__FCPi_PiiPi__1(int *__a__Pi_1, int __b__i_1, int *__c__Pi_1){
-    __attribute__ ((unused)) int *const ___retval_f9__CPi_1;
+signed int *const __f9__FCPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
+    __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1;
 }
-int *(*__f10__FPFPi_ii__iPiPid__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1, double __y__d_1))(int __x__i_1, int __y__i_1){
-    __attribute__ ((unused)) int *(*___retval_f10__PFPi_ii__1)(int __x__i_1, int __y__i_1);
-    int *__x__FPi_ii__2(int __anonymous_object2, int __anonymous_object3);
+signed int *(*__f10__FPFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
+    __attribute__ ((unused)) signed int *(*___retval_f10__PFPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
+    signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
     ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
-    return ((int *(*)(int __x__i_1, int __y__i_1))___retval_f10__PFPi_ii__1);
+    return ((signed int *(*)(signed int __x__i_1, signed int __y__i_1))___retval_f10__PFPi_ii__1);
 }
-int (*__f11__FPA0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[]{
-    __attribute__ ((unused)) int (*___retval_f11__PA0i_1)[];
+signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{
+    __attribute__ ((unused)) signed int (*___retval_f11__PA0i_1)[];
 }
-int (*__f12__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
-    __attribute__ ((unused)) int (*___retval_f12__PA0A0i_1)[][((long unsigned int )10)];
+signed int (*__f12__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
+    __attribute__ ((unused)) signed int (*___retval_f12__PA0A0i_1)[][((unsigned long int )10)];
 }
-int (*__f13__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
-    __attribute__ ((unused)) int (*___retval_f13__PA0A0i_1)[][((long unsigned int )10)];
+signed int (*__f13__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
+    __attribute__ ((unused)) signed int (*___retval_f13__PA0A0i_1)[][((unsigned long int )10)];
 }
-int (*__f14__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
-    __attribute__ ((unused)) int (*___retval_f14__PA0A0i_1)[][((long unsigned int )10)];
+signed int (*__f14__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
+    __attribute__ ((unused)) signed int (*___retval_f14__PA0A0i_1)[][((unsigned long int )10)];
 }
-int __f15__Fi_iii__1(int __a__i_1, int __b__i_1, int __c__i_1){
-    __attribute__ ((unused)) int ___retval_f15__i_1;
+signed int __f15__Fi_iii__1(signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
+    __attribute__ ((unused)) signed int ___retval_f15__i_1;
 }
-const int __fred__FCi___1(){
-    __attribute__ ((unused)) const int ___retval_fred__Ci_1;
-    int *(*__x__PFPi_ii__2)(int __anonymous_object4, int __anonymous_object5);
-    int __a__i_2;
-    int __b__i_2;
-    int *(*_tmp_cp_ret0)(int __x__i_1, int __y__i_1);
+const signed int __fred__FCi___1(){
+    __attribute__ ((unused)) const signed int ___retval_fred__Ci_1;
+    signed int *(*__x__PFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
+    signed int __a__i_2;
+    signed int __b__i_2;
+    signed int *(*_tmp_cp_ret0)(signed int __x__i_1, signed int __y__i_1);
     ((void)(__x__PFPi_ii__2=(((void)(_tmp_cp_ret0=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret0)));
     ((void)(_tmp_cp_ret0) /* ^?{} */);
-    const int __f1__FCi_iPiPi__2(int __a__i_2, int *__b__Pi_2, int *__c__Pi_2){
-        __attribute__ ((unused)) const int ___retval_f1__Ci_2;
+    const signed int __f1__FCi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
+        __attribute__ ((unused)) const signed int ___retval_f1__Ci_2;
     }
-    const int __f2__FCi_iii__2(int __a__i_2, int __b__i_2, int __c__i_2){
-        __attribute__ ((unused)) const int ___retval_f2__Ci_2;
+    const signed int __f2__FCi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+        __attribute__ ((unused)) const signed int ___retval_f2__Ci_2;
     }
 }

src/tests/.expect/64/attributes.txt

@@ -1 @@
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
+__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-int __la__Fi___1(){
-    __attribute__ ((unused)) int ___retval_la__i_1;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+signed int __la__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_la__i_1;
     L: __attribute__ ((unused)) ((void)1);
 }
@@ -54 +54 @@
 __attribute__ ((unused)) struct __anonymous3;
 struct Fdl {
-    __attribute__ ((unused)) int __f1__i_1;
-    __attribute__ ((unused)) int __f2__i_1;
-    __attribute__ ((unused,unused)) int __f3__i_1;
-    __attribute__ ((unused)) int __f4__i_1;
-    __attribute__ ((unused,unused)) int __f5__i_1;
-    __attribute__ ((used,packed)) int __f6__i_1;
-    __attribute__ ((used,unused,unused)) int __f7__i_1;
-    __attribute__ ((used,used,unused)) int __f8__i_1;
-    __attribute__ ((unused)) int __anonymous_object0;
-    __attribute__ ((unused,unused)) int *__f9__Pi_1;
+    __attribute__ ((unused)) signed int __f1__i_1;
+    __attribute__ ((unused)) signed int __f2__i_1;
+    __attribute__ ((unused,unused)) signed int __f3__i_1;
+    __attribute__ ((unused)) signed int __f4__i_1;
+    __attribute__ ((unused,unused)) signed int __f5__i_1;
+    __attribute__ ((used,packed)) signed int __f6__i_1;
+    __attribute__ ((used,unused,unused)) signed int __f7__i_1;
+    __attribute__ ((used,used,unused)) signed int __f8__i_1;
+    __attribute__ ((unused)) signed int __anonymous_object0;
+    __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
 };
 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
@@ -116 +116 @@
     return ((struct Fdl )___ret__4sFdl_1);
 }
-static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1){
+static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */);
@@ -127 +127 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1){
+static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -138 +138 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1){
+static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -149 +149 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1){
-    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
-}
-static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1){
-    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
-    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
-}
-static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1){
+static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1){
+    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1){
+    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -182 +182 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1){
+static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -193 +193 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1){
+static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -204 +204 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
 }
-static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1, int *__f9__Pi_1){
+static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int *__f9__Pi_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
@@ -215 +215 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
 }
-__attribute__ ((unused)) int __f__Fi___1() asm ( "xyz" );
-__attribute__ ((used,used)) const int __vd1__Ci_1;
-__attribute__ ((used,unused)) const int __vd2__Ci_1;
-__attribute__ ((used,used,used,used)) const int *__vd3__PCi_1;
-__attribute__ ((used,used,unused,used,unused)) const int *__vd4__PCi_1;
-__attribute__ ((used,used,used)) const int __vd5__A0Ci_1[((long unsigned int )5)];
-__attribute__ ((used,used,unused,used)) const int __vd6__A0Ci_1[((long unsigned int )5)];
-__attribute__ ((used,used,used,used)) const int (*__vd7__PFCi___1)();
-__attribute__ ((used,used,unused,used,used)) const int (*__vd8__PFCi___1)();
-__attribute__ ((unused,used)) int __f1__Fi___1();
-__attribute__ ((unused)) int __f1__Fi___1(){
-    __attribute__ ((unused)) int ___retval_f1__i_1;
-}
-__attribute__ ((unused,unused,unused,used)) int **const __f2__FCPPi___1();
-__attribute__ ((unused,unused,unused)) int **const __f2__FCPPi___1(){
-    __attribute__ ((unused)) int **const ___retval_f2__CPPi_1;
-}
-__attribute__ ((unused,used,unused)) int (*__f3__FPA0i_i__1(int __anonymous_object1))[];
-__attribute__ ((unused,unused)) int (*__f3__FPA0i_i__1(int __p__i_1))[]{
-    __attribute__ ((unused)) int (*___retval_f3__PA0i_1)[];
-}
-__attribute__ ((unused,used,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object2);
-__attribute__ ((unused,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object3){
-    __attribute__ ((unused)) int (*___retval_f4__PFi_i__1)(int __anonymous_object4);
-}
-int __vtr__Fi___1(){
-    __attribute__ ((unused)) int ___retval_vtr__i_1;
-    __attribute__ ((unused,unused,used)) int __t1__i_2;
-    __attribute__ ((unused,unused,unused,unused,unused)) int **__t2__PPi_2;
-    __attribute__ ((unused,unused,unused)) int __t3__A0i_2[((long unsigned int )5)];
-    __attribute__ ((unused,unused,unused,unused,unused)) int **__t4__A0PPi_2[((long unsigned int )5)];
-    __attribute__ ((unused,unused,unused)) int __t5__Fi___2();
-    __attribute__ ((unused,unused,unused,unused)) int *__t6__FPi___2();
-}
-int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1);
-int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1){
-    __attribute__ ((unused)) int ___retval_ipd1__i_1;
-}
-int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
-int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
-    __attribute__ ((unused)) int ___retval_ipd2__i_1;
-}
-int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
-int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
-    __attribute__ ((unused)) int ___retval_ipd3__i_1;
-}
-int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)());
-int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)()){
-    __attribute__ ((unused)) int ___retval_ipd4__i_1;
-}
-int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) int __Foo__i_1);
-int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) int **__Foo__PPi_1);
-int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) int *__Foo__Pi_1);
-int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) int (*__anonymous_object5)(__attribute__ ((unused,unused)) int __anonymous_object6[((long unsigned int )5)]));
-int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) int (*__Foo__PFi___1)());
-int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) int (*__Foo__PFi___1)());
-int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) int (*__anonymous_object7)(__attribute__ ((unused)) int (*__anonymous_object8)(__attribute__ ((unused,unused)) int __anonymous_object9)));
-int __ad__Fi___1(){
-    __attribute__ ((unused)) int ___retval_ad__i_1;
-    __attribute__ ((used,unused)) int __ad1__i_2;
-    __attribute__ ((unused,unused,unused)) int *__ad2__Pi_2;
-    __attribute__ ((unused,unused,unused)) int __ad3__A0i_2[((long unsigned int )5)];
-    __attribute__ ((unused,unused,unused,unused,unused)) int (*__ad4__PA0i_2)[((long unsigned int )10)];
-    __attribute__ ((unused,unused,unused,unused,used)) int __ad5__i_2;
-    __attribute__ ((unused,unused,unused,unused,unused)) int __ad6__Fi___2();
-    ((void)sizeof(__attribute__ ((unused,unused)) int ));
-    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) int **));
-    ((void)sizeof(__attribute__ ((unused,unused,unused)) int [5]));
-    ((void)sizeof(__attribute__ ((unused,unused,unused)) int (*)[10]));
-    ((void)sizeof(__attribute__ ((unused,unused,unused)) int ()));
+__attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
+__attribute__ ((used,used)) const signed int __vd1__Ci_1;
+__attribute__ ((used,unused)) const signed int __vd2__Ci_1;
+__attribute__ ((used,used,used,used)) const signed int *__vd3__PCi_1;
+__attribute__ ((used,used,unused,used,unused)) const signed int *__vd4__PCi_1;
+__attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned long int )5)];
+__attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned long int )5)];
+__attribute__ ((used,used,used,used)) const signed int (*__vd7__PFCi___1)();
+__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__PFCi___1)();
+__attribute__ ((unused,used)) signed int __f1__Fi___1();
+__attribute__ ((unused)) signed int __f1__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_f1__i_1;
+}
+__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FCPPi___1();
+__attribute__ ((unused,unused,unused)) signed int **const __f2__FCPPi___1(){
+    __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
+}
+__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object1))[];
+__attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
+    __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object2);
+__attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object3){
+    __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object4);
+}
+signed int __vtr__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_vtr__i_1;
+    __attribute__ ((unused,unused,used)) signed int __t1__i_2;
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t2__PPi_2;
+    __attribute__ ((unused,unused,unused)) signed int __t3__A0i_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t4__A0PPi_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused)) signed int __t5__Fi___2();
+    __attribute__ ((unused,unused,unused,unused)) signed int *__t6__FPi___2();
+}
+signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1);
+signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1){
+    __attribute__ ((unused)) signed int ___retval_ipd1__i_1;
+}
+signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
+signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_ipd2__i_1;
+}
+signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
+signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
+}
+signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)());
+signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)()){
+    __attribute__ ((unused)) signed int ___retval_ipd4__i_1;
+}
+signed int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) signed int __Foo__i_1);
+signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
+signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
+signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object5)(__attribute__ ((unused,unused)) signed int __anonymous_object6[((unsigned long int )5)]));
+signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
+signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
+signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object7)(__attribute__ ((unused)) signed int (*__anonymous_object8)(__attribute__ ((unused,unused)) signed int __anonymous_object9)));
+signed int __ad__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_ad__i_1;
+    __attribute__ ((used,unused)) signed int __ad1__i_2;
+    __attribute__ ((unused,unused,unused)) signed int *__ad2__Pi_2;
+    __attribute__ ((unused,unused,unused)) signed int __ad3__A0i_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*__ad4__PA0i_2)[((unsigned long int )10)];
+    __attribute__ ((unused,unused,unused,unused,used)) signed int __ad5__i_2;
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int __ad6__Fi___2();
+    ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
+    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
+    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [5]));
+    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[10]));
+    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
     __attribute__ ((unused)) struct __anonymous4 {
-        int __i__i_2;
+        signed int __i__i_2;
     };
     inline void ___constructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
@@ -303 +303 @@
         return ((struct __anonymous4 )___ret__13s__anonymous4_2);
     }
-    inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, int __i__i_2){
+    inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
     }
@@ -324 +324 @@
     ((void)sizeof(enum __anonymous5 ));
 }
-int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object10, __attribute__ ((unused,unused,unused)) int *__anonymous_object11);
-int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) int **__anonymous_object13);
-int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object14, __attribute__ ((unused,unused,unused)) int *__anonymous_object15);
-int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) int (*__anonymous_object17)());
-int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object18)(__attribute__ ((unused)) int __anonymous_object19), __attribute__ ((unused,unused,unused)) int (*__anonymous_object20)(__attribute__ ((unused)) int __anonymous_object21));
-int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) int (*__anonymous_object23)());
-int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object24)(__attribute__ ((unused)) int __anonymous_object25), __attribute__ ((unused,unused,unused)) int (*__anonymous_object26)(__attribute__ ((unused)) int __anonymous_object27));
+signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object10, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object11);
+signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object13);
+signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
+signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)());
+signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object18)(__attribute__ ((unused)) signed int __anonymous_object19), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(__attribute__ ((unused)) signed int __anonymous_object21));
+signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)());
+signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(__attribute__ ((unused)) signed int __anonymous_object27));
 struct Vad {
-    __attribute__ ((unused)) int __anonymous_object28;
-    __attribute__ ((unused,unused)) int *__anonymous_object29;
-    __attribute__ ((unused,unused)) int __anonymous_object30[((long unsigned int )10)];
-    __attribute__ ((unused,unused)) int (*__anonymous_object31)();
+    __attribute__ ((unused)) signed int __anonymous_object28;
+    __attribute__ ((unused,unused)) signed int *__anonymous_object29;
+    __attribute__ ((unused,unused)) signed int __anonymous_object30[((unsigned long int )10)];
+    __attribute__ ((unused,unused)) signed int (*__anonymous_object31)();
 };
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);

src/tests/.expect/64/declarationSpecifier.txt

@@ -1 @@
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
+__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-volatile const short __x1__CVs_1;
-static volatile const short __x2__CVs_1;
-static volatile const short __x3__CVs_1;
-static volatile const short __x4__CVs_1;
-static volatile const short __x5__CVs_1;
-static volatile const short __x6__CVs_1;
-static volatile const short __x7__CVs_1;
-static volatile const short __x8__CVs_1;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+volatile const signed short int __x1__CVs_1;
+static volatile const signed short int __x2__CVs_1;
+static volatile const signed short int __x3__CVs_1;
+static volatile const signed short int __x4__CVs_1;
+static volatile const signed short int __x5__CVs_1;
+static volatile const signed short int __x6__CVs_1;
+static volatile const signed short int __x7__CVs_1;
+static volatile const signed short int __x8__CVs_1;
 struct __anonymous0 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
@@ -35 +35 @@
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
 }
-static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
 struct __anonymous1 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
@@ -61 +61 @@
     return ((struct __anonymous1 )___ret__13s__anonymous1_1);
 }
-static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
 struct __anonymous2 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
@@ -87 +87 @@
     return ((struct __anonymous2 )___ret__13s__anonymous2_1);
 }
-static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
 struct __anonymous3 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
@@ -113 +113 @@
     return ((struct __anonymous3 )___ret__13s__anonymous3_1);
 }
-static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
 struct __anonymous4 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
@@ -139 +139 @@
     return ((struct __anonymous4 )___ret__13s__anonymous4_1);
 }
-static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
 struct __anonymous5 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
@@ -165 +165 @@
     return ((struct __anonymous5 )___ret__13s__anonymous5_1);
 }
-static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
 struct __anonymous6 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
@@ -191 +191 @@
     return ((struct __anonymous6 )___ret__13s__anonymous6_1);
 }
-static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
 struct __anonymous7 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
@@ -217 +217 @@
     return ((struct __anonymous7 )___ret__13s__anonymous7_1);
 }
-static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, int __i__i_1){
+static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
-volatile const short __x20__CVs_1;
-static volatile const short __x21__CVs_1;
-static volatile const short __x22__CVs_1;
-static volatile const short __x23__CVs_1;
-static volatile const short __x24__CVs_1;
-static volatile const short __x25__CVs_1;
-static volatile const short __x26__CVs_1;
-static volatile const short __x27__CVs_1;
+volatile const signed short int __x20__CVs_1;
+static volatile const signed short int __x21__CVs_1;
+static volatile const signed short int __x22__CVs_1;
+static volatile const signed short int __x23__CVs_1;
+static volatile const signed short int __x24__CVs_1;
+static volatile const signed short int __x25__CVs_1;
+static volatile const signed short int __x26__CVs_1;
+static volatile const signed short int __x27__CVs_1;
 struct __anonymous8 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
@@ -251 +251 @@
     return ((struct __anonymous8 )___ret__13s__anonymous8_1);
 }
-static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, short __i__s_1){
+static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
 struct __anonymous9 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
@@ -277 +277 @@
     return ((struct __anonymous9 )___ret__13s__anonymous9_1);
 }
-static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, short __i__s_1){
+static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
 struct __anonymous10 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
@@ -303 +303 @@
     return ((struct __anonymous10 )___ret__14s__anonymous10_1);
 }
-static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
 struct __anonymous11 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
@@ -329 +329 @@
     return ((struct __anonymous11 )___ret__14s__anonymous11_1);
 }
-static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
 struct __anonymous12 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
@@ -355 +355 @@
     return ((struct __anonymous12 )___ret__14s__anonymous12_1);
 }
-static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
 struct __anonymous13 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
@@ -381 +381 @@
     return ((struct __anonymous13 )___ret__14s__anonymous13_1);
 }
-static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
 struct __anonymous14 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
@@ -407 +407 @@
     return ((struct __anonymous14 )___ret__14s__anonymous14_1);
 }
-static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1;
 struct __anonymous15 {
-    short __i__s_1;
+    signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1);
@@ -433 +433 @@
     return ((struct __anonymous15 )___ret__14s__anonymous15_1);
 }
-static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, short __i__s_1){
+static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
 }
 static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1;
-static inline volatile const int __f11__FCVi___1();
-static inline volatile const int __f12__FCVi___1();
-static inline volatile const int __f13__FCVi___1();
-static inline volatile const int __f14__FCVi___1();
-static inline volatile const int __f15__FCVi___1();
-static inline volatile const int __f16__FCVi___1();
-static inline volatile const int __f17__FCVi___1();
-static inline volatile const int __f18__FCVi___1();
-static inline volatile const short __f21__FCVs___1();
-static inline volatile const short __f22__FCVs___1();
-static inline volatile const short __f23__FCVs___1();
-static inline volatile const short __f24__FCVs___1();
-static inline volatile const short __f25__FCVs___1();
-static inline volatile const short __f26__FCVs___1();
-static inline volatile const short __f27__FCVs___1();
-static inline volatile const short __f28__FCVs___1();
+static inline volatile const signed int __f11__FCVi___1();
+static inline volatile const signed int __f12__FCVi___1();
+static inline volatile const signed int __f13__FCVi___1();
+static inline volatile const signed int __f14__FCVi___1();
+static inline volatile const signed int __f15__FCVi___1();
+static inline volatile const signed int __f16__FCVi___1();
+static inline volatile const signed int __f17__FCVi___1();
+static inline volatile const signed int __f18__FCVi___1();
+static inline volatile const signed short int __f21__FCVs___1();
+static inline volatile const signed short int __f22__FCVs___1();
+static inline volatile const signed short int __f23__FCVs___1();
+static inline volatile const signed short int __f24__FCVs___1();
+static inline volatile const signed short int __f25__FCVs___1();
+static inline volatile const signed short int __f26__FCVs___1();
+static inline volatile const signed short int __f27__FCVs___1();
+static inline volatile const signed short int __f28__FCVs___1();
 struct __anonymous16 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1);
@@ -475 +475 @@
     return ((struct __anonymous16 )___ret__14s__anonymous16_1);
 }
-static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous16 __f31__FCV14s__anonymous16___1();
 struct __anonymous17 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1);
@@ -501 +501 @@
     return ((struct __anonymous17 )___ret__14s__anonymous17_1);
 }
-static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous17 __f32__FCV14s__anonymous17___1();
 struct __anonymous18 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1);
@@ -527 +527 @@
     return ((struct __anonymous18 )___ret__14s__anonymous18_1);
 }
-static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous18 __f33__FCV14s__anonymous18___1();
 struct __anonymous19 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1);
@@ -553 +553 @@
     return ((struct __anonymous19 )___ret__14s__anonymous19_1);
 }
-static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous19 __f34__FCV14s__anonymous19___1();
 struct __anonymous20 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1);
@@ -579 +579 @@
     return ((struct __anonymous20 )___ret__14s__anonymous20_1);
 }
-static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous20 __f35__FCV14s__anonymous20___1();
 struct __anonymous21 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1);
@@ -605 +605 @@
     return ((struct __anonymous21 )___ret__14s__anonymous21_1);
 }
-static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous21 __f36__FCV14s__anonymous21___1();
 struct __anonymous22 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1);
@@ -631 +631 @@
     return ((struct __anonymous22 )___ret__14s__anonymous22_1);
 }
-static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous22 __f37__FCV14s__anonymous22___1();
 struct __anonymous23 {
-    int __i__i_1;
+    signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1);
@@ -657 +657 @@
     return ((struct __anonymous23 )___ret__14s__anonymous23_1);
 }
-static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, int __i__i_1){
+static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */);
 }
 static inline volatile const struct __anonymous23 __f38__FCV14s__anonymous23___1();
-static inline volatile const short __f41__FCVs___1();
-static inline volatile const short __f42__FCVs___1();
-static inline volatile const short __f43__FCVs___1();
-static inline volatile const short __f44__FCVs___1();
-static inline volatile const short __f45__FCVs___1();
-static inline volatile const short __f46__FCVs___1();
-static inline volatile const short __f47__FCVs___1();
-static inline volatile const short __f48__FCVs___1();
-int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
-    __attribute__ ((unused)) int ___retval_main__i_1;
-    ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
-    return ((int )___retval_main__i_1);
+static inline volatile const signed short int __f41__FCVs___1();
+static inline volatile const signed short int __f42__FCVs___1();
+static inline volatile const signed short int __f43__FCVs___1();
+static inline volatile const signed short int __f44__FCVs___1();
+static inline volatile const signed short int __f45__FCVs___1();
+static inline volatile const signed short int __f46__FCVs___1();
+static inline volatile const signed short int __f47__FCVs___1();
+static inline volatile const signed short int __f48__FCVs___1();
+signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
+    __attribute__ ((unused)) signed int ___retval_main__i_1;
+    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
+    return ((signed int )___retval_main__i_1);
     ((void)(___retval_main__i_1=0) /* ?{} */);
-    return ((int )___retval_main__i_1);
+    return ((signed int )___retval_main__i_1);
 }
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
+__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-static inline int invoke_main(int argc, char **argv, char **envp);
-int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
-    __attribute__ ((unused)) int ___retval_main__i_1;
-    int _tmp_cp_ret0;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+static inline signed int invoke_main(signed int argc, char **argv, char **envp);
+signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
+    __attribute__ ((unused)) signed int ___retval_main__i_1;
+    signed int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
-    return ((int )___retval_main__i_1);
-}
+    return ((signed int )___retval_main__i_1);
+}

src/tests/.expect/64/extension.txt

@@ -1 @@
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
+__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-__extension__ int __a__i_1;
-__extension__ int __b__i_1;
-__extension__ int __c__i_1;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+__extension__ signed int __a__i_1;
+__extension__ signed int __b__i_1;
+__extension__ signed int __c__i_1;
 __extension__ struct S {
-    __extension__ int __a__i_1;
-    __extension__ int __b__i_1;
-    __extension__ int __c__i_1;
+    __extension__ signed int __a__i_1;
+    __extension__ signed int __b__i_1;
+    __extension__ signed int __c__i_1;
 };
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
@@ -40 +40 @@
     return ((struct S )___ret__2sS_1);
 }
-static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __a__i_1){
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
 }
-static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1){
+static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
 }
-static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1, int __c__i_1){
+static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
@@ -56 +56 @@
 }
 __extension__ union U {
-    __extension__ int __a__i_1;
-    __extension__ int __b__i_1;
-    __extension__ int __c__i_1;
+    __extension__ signed int __a__i_1;
+    __extension__ signed int __b__i_1;
+    __extension__ signed int __c__i_1;
 };
 static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
@@ -73 +73 @@
     return ((union U )___ret__2uU_1);
 }
-static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, int __src__i_1){
-    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(int )));
+static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, signed int __src__i_1){
+    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(signed int )));
 }
 __extension__ enum E {
@@ -81 +81 @@
     __B__C2eE_1,
 };
-__extension__ int __f__Fi___1();
-__extension__ int i;
-__extension__ int j;
-__extension__ int __fred__Fi_i__1(int __p__i_1){
-    __attribute__ ((unused)) int ___retval_fred__i_1;
+__extension__ signed int __f__Fi___1();
+__extension__ signed int i;
+__extension__ signed int j;
+__extension__ signed int __fred__Fi_i__1(signed int __p__i_1){
+    __attribute__ ((unused)) signed int ___retval_fred__i_1;
     __extension__ struct S {
-        __extension__ int __a__i_2;
-        __extension__ int __b__i_2;
-        __extension__ int __c__i_2;
-        __extension__ int *__x__Pi_2;
-        __extension__ int *__y__Pi_2;
-        __extension__ int *__z__Pi_2;
+        __extension__ signed int __a__i_2;
+        __extension__ signed int __b__i_2;
+        __extension__ signed int __c__i_2;
+        __extension__ signed int *__x__Pi_2;
+        __extension__ signed int *__y__Pi_2;
+        __extension__ signed int *__z__Pi_2;
     };
-    int __i__i_2 = ((int )(__extension__ __a__i_1+__extension__ 3));
+    signed int __i__i_2 = ((signed int )(__extension__ __a__i_1+__extension__ 3));
     ((void)__extension__ 3);
     ((void)__extension__ __a__i_1);
-    __extension__ int __a__i_2;
-    __extension__ int __b__i_2;
-    __extension__ int __c__i_2;
+    __extension__ signed int __a__i_2;
+    __extension__ signed int __b__i_2;
+    __extension__ signed int __c__i_2;
     ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
-    int _tmp_cp_ret0;
+    signed int _tmp_cp_ret0;
     ((void)(((void)(_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3))) , _tmp_cp_ret0));
     ((void)(_tmp_cp_ret0) /* ^?{} */);
-    __extension__ int __mary__Fi_i__2(int __p__i_2){
-        __attribute__ ((unused)) int ___retval_mary__i_2;
+    __extension__ signed int __mary__Fi_i__2(signed int __p__i_2){
+        __attribute__ ((unused)) signed int ___retval_mary__i_2;
     }
     ((void)__extension__ sizeof(3));
-    ((void)__extension__ (((int )(3!=((int )0))) || ((int )(4!=((int )0)))));
+    ((void)__extension__ (((signed int )(3!=((signed int )0))) || ((signed int )(4!=((signed int )0)))));
     ((void)__extension__ __alignof__(__extension__ __a__i_2));
-    ((void)(((int )(__extension__ __a__i_2!=((int )0))) || ((int )((((int )(__extension__ __b__i_2!=((int )0))) && ((int )(__extension__ __c__i_2!=((int )0))))!=((int )0)))));
-    ((void)(((int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
+    ((void)(((signed int )(__extension__ __a__i_2!=((signed int )0))) || ((signed int )((((signed int )(__extension__ __b__i_2!=((signed int )0))) && ((signed int )(__extension__ __c__i_2!=((signed int )0))))!=((signed int )0)))));
+    ((void)(((signed int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
     ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
     ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));

src/tests/.expect/64/gccExtensions.txt

@@ -1 @@
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
+__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-extern int __x__i_1 asm ( "xx" );
-int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
-    __attribute__ ((unused)) int ___retval_main__i_1;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+extern signed int __x__i_1 asm ( "xx" );
+signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
+    __attribute__ ((unused)) signed int ___retval_main__i_1;
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
-    static int __y__i_2 asm ( "yy" );
-    static int *__z__Pi_2 asm ( "zz" );
-    int __src__i_2;
-    int __dst__i_2;
-    asm volatile ( "mov %1, %0\n\tadd $1, %0" :  :  :  );
-    asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) :  :  );
-    asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
-    asm ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
+    static signed int __y__i_2 asm ( "yy" );
+    static signed int *__z__Pi_2 asm ( "zz" );
+    signed int __src__i_2;
+    signed int __dst__i_2;
+    asm volatile ( "mov %1, %0\n\t" "add $1, %0" :  :  :  );
+    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( __dst__i_2 ) :  :  );
+    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
+    asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
     L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" :  : "r" ( __src__i_2 ), "r" ( (&__dst__i_2) ) : "r5", "memory" : L1, L2 );
     double _Complex __c1__Xd_2;
     double _Complex __c2__Xd_2;
-    const int __i1__Ci_2;
-    const int __i2__Ci_2;
-    const int __i3__Ci_2;
-    inline int __f1__Fi___2(){
-        __attribute__ ((unused)) int ___retval_f1__i_2;
+    const signed int __i1__Ci_2;
+    const signed int __i2__Ci_2;
+    const signed int __i3__Ci_2;
+    inline signed int __f1__Fi___2(){
+        __attribute__ ((unused)) signed int ___retval_f1__i_2;
     }
-    inline int __f2__Fi___2(){
-        __attribute__ ((unused)) int ___retval_f2__i_2;
+    inline signed int __f2__Fi___2(){
+        __attribute__ ((unused)) signed int ___retval_f2__i_2;
     }
-    int __s1__i_2;
-    int __s2__i_2;
-    volatile int __v1__Vi_2;
-    volatile int __v2__Vi_2;
-    int __t1___2;
-    int __t2___2;
-    __extension__ const int __ex__Ci_2;
+    signed int __s1__i_2;
+    signed int __s2__i_2;
+    volatile signed int __v1__Vi_2;
+    volatile signed int __v2__Vi_2;
+    signed int __t1___2;
+    signed int __t2___2;
+    __extension__ const signed int __ex__Ci_2;
     struct S {
-        __extension__ int __a__i_2;
-        __extension__ int __b__i_2;
-        __extension__ int __c__i_2;
+        __extension__ signed int __a__i_2;
+        __extension__ signed int __b__i_2;
+        __extension__ signed int __c__i_2;
     };
     inline void ___constructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
@@ -66 +66 @@
         return ((struct S )___ret__2sS_2);
     }
-    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, int __a__i_2){
+    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
         ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
     }
-    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2){
+    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2){
         ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
     }
-    inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2, int __c__i_2){
+    inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
         ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
         ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
     }
-    int __i__i_2 = ((int )__extension__ 3);
-    __extension__ int __a__i_2;
-    __extension__ int __b__i_2;
-    __extension__ int __c__i_2;
+    signed int __i__i_2 = ((signed int )__extension__ 3);
+    __extension__ signed int __a__i_2;
+    __extension__ signed int __b__i_2;
+    __extension__ signed int __c__i_2;
     ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
     ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
     ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
-    int __a1__i_2;
-    const int __a2__Ci_2;
-    static const int __a3__Ci_2;
-    static const int __a4__Ci_2;
-    static const int __a5__Ci_2;
-    static const int __a6__Ci_2;
-    static const int __a7__Ci_2;
-    int *__p1__Pi_2;
-    int *__p2__Pi_2;
+    signed int __a1__i_2;
+    const signed int __a2__Ci_2;
+    static const signed int __a3__Ci_2;
+    static const signed int __a4__Ci_2;
+    static const signed int __a5__Ci_2;
+    static const signed int __a6__Ci_2;
+    static const signed int __a7__Ci_2;
+    signed int *__p1__Pi_2;
+    signed int *__p2__Pi_2;
     struct s1;
     struct s2 {
-        int __i__i_2;
+        signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){
@@ -116 +116 @@
         return ((struct s2 )___ret__3ss2_2);
     }
-    inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, int __i__i_2){
+    inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
         ((void)((*___dst__R3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
     }
     struct s3 {
-        int __i__i_2;
+        signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){
@@ -137 +137 @@
         return ((struct s3 )___ret__3ss3_2);
     }
-    inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, int __i__i_2){
+    inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
         ((void)((*___dst__R3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
     }
@@ -143 +143 @@
     struct s3 __y1__3ss3_2;
     struct s4 {
-        int __i__i_2;
+        signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){
@@ -160 +160 @@
         return ((struct s4 )___ret__3ss4_2);
     }
-    inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, int __i__i_2){
+    inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
         ((void)((*___dst__R3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
     }
     struct s4 __x2__3ss4_2;
     struct s4 __y2__3ss4_2;
-    int __m1__A0i_2[((long unsigned int )10)];
-    int __m2__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)];
-    int __m3__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)];
-    ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
-    return ((int )___retval_main__i_1);
+    signed int __m1__A0i_2[((unsigned long int )10)];
+    signed int __m2__A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
+    signed int __m3__A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
+    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
+    return ((signed int )___retval_main__i_1);
     ((void)(___retval_main__i_1=0) /* ?{} */);
-    return ((int )___retval_main__i_1);
+    return ((signed int )___retval_main__i_1);
 }
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
+__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
-extern int printf(const char *__restrict __format, ...);
-static inline int invoke_main(int argc, char **argv, char **envp);
-int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
-    __attribute__ ((unused)) int ___retval_main__i_1;
-    int _tmp_cp_ret0;
+__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
+__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
+extern signed int printf(const char *__restrict __format, ...);
+static inline signed int invoke_main(signed int argc, char **argv, char **envp);
+signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
+    __attribute__ ((unused)) signed int ___retval_main__i_1;
+    signed int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
-    return ((int )___retval_main__i_1);
+    return ((signed int )___retval_main__i_1);
 }

src/tests/.expect/io.txt

@@ -27 +27 @@
 
 output basic types
-A 
+A 23 93
 1 2 3 4 5 6 7 8
 1.1 1.2 1.3

src/tests/.expect/user_literals.txt

@@ -5 +5 @@
 11.0714285714286
 22.0457142857143
+secs 1
+secs 23
+mins 23
+hours 23
+_A_ 23
+_thingy_ 1234
+secs 65535
+mins 65535
+hours 65535
+_A_ 65535
+_thingy_ 65535
+secs 10
+hours 10
+mins 10
+_A_ 10
+_thingy_ 10
+secs abc
+mins 
+hours abc
+_A_ abc
+_thingy_ abc

src/tests/Makefile.am

@@ -11 +11 @@
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Thu Jun  8 07:41:43 2017
-## Update Count     : 44
+## Last Modified On : Mon Sep 11 16:17:16 2017
+## Update Count     : 45
 ###############################################################################
 
@@ -101 +101 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 
+literals : literals.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+
 gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}

src/tests/Makefile.in

@@ -853 +853 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 
+literals : literals.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+
 gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}

src/tests/io.c

@@ -10 +10 @@
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 23 21:27:50 2017
-// Update Count     : 79
+// Last Modified On : Mon Sep 11 08:53:41 2017
+// Update Count     : 81
 // 
 
@@ -18 +18 @@
 int main() {
         char c;                                                                                         // basic types
+        signed char sc;
+        unsigned char usc;
         short int si;
         unsigned short int usi;
@@ -89 +91 @@
 
         sout | "input bacis types" | endl;
-        &in | c                                                                                         // character
+        &in | c | sc | usc                                                                      // character
                 | si | usi | i | ui | li | uli | lli | ulli             // integral
                 | f | d | ld                                                                    // floating point
@@ -97 +99 @@
 
         sout | "output basic types" | endl;
-        sout | c | ' ' | endl                                                           // character
+        sout | c | ' ' | sc | ' ' | usc | endl                          // character
                 | si | usi | i | ui | li | uli | lli | ulli | endl // integral
                 | f | d | ld | endl                                                             // floating point

src/tests/io.data

@@ -1 @@
-A 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz
+A 23 93 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz

src/tests/user_literals.c

@@ -10 +10 @@
 // Created On       : Wed Sep  6 21:40:50 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Sep  6 23:19:08 2017
-// Update Count     : 36
+// Last Modified On : Sat Sep  9 08:31:32 2017
+// Update Count     : 48
 // 
 
 #include <fstream>
+#include <wchar.h>
+#include <uchar.h>
+
+int ?`s( int s ) { sout | "secs" | s | endl; return s; }
+int ?`m( int m ) { sout | "mins" | m | endl; return m * 60; }
+int ?`h( int h ) { sout | "hours" | h | endl; return h * 3600; }
+int ?`_A_( int x ) { sout | "_A_" | x | endl; return x; }
+int ?`__thingy_( int x ) { sout | "_thingy_" | x | endl; return x; }
+
+int ?`s( const char * s ) { sout | "secs" | s | endl; return 0; }
+int ?`m( const char16_t * m ) { sout | "mins" | m | endl; return 0;}
+int ?`h( const char32_t * h ) { sout | "hours" | h | endl; return 0; }
+int ?`_A_( const wchar_t * str ) { sout | "_A_" | str | endl; return 0; }
+int ?`__thingy_( const char * str ) { sout | "_thingy_" | str | endl; return 0; }
+
 
 struct Weight {
-    double stones;
+        double stones;
 };
-void ?{}( Weight & w ) { w.stones = 0; }        // constructors
+void ?{}( Weight & w ) { w.stones = 0; }                                // operations
 void ?{}( Weight & w, double w ) { w.stones = w; }
-
 Weight ?+?( Weight l, Weight r ) { return (Weight){ l.stones + r.stones }; }
 ofstream * ?|?( ofstream * os, Weight w ) { return os | w.stones; }
 
-Weight ?`st( double w ) { return (Weight){ w }; } // user literals
+Weight ?`st( double w ) { return (Weight){ w }; }               // backquote for user literals
 Weight ?`lb( double w ) { return (Weight){ w / 14.0 }; }
 Weight ?`kg( double w ) { return (Weight) { w * 0.1575}; }
 
+
 int main() {
-    Weight w, hw = { 14 };
-    w = 11`st + 1`lb;
-    sout | w | endl;
-    w = 70.3`kg;
-    sout | w | endl;
-    w = 155`lb;
-    sout | w | endl;
-    w = 0x9b`lb;                // hexadecimal weight
-    sout | w | endl;
-    w = 0233`lb;                // octal weight
-    sout | w | endl;
-    w = 5`st + 8`kg + 25`lb + hw;
-    sout | w | endl;
-}
+        Weight w, hw = { 14 };                                                          // 14 stone
+        w = 11`st + 1`lb;
+        sout | w | endl;
+        w = 70.3`kg;
+        sout | w | endl;
+        w = 155`lb;
+        sout | w | endl;
+        w = 0x_9b_u`lb;                                                                         // hexadecimal unsigned weight (155)
+        sout | w | endl;
+        w = 0_233`lb;                                                                           // octal weight (155)
+        sout | w | endl;
+        w = 5`st + 8`kg + 25`lb + hw;
+        sout | w | endl;
 
+//      0`secs;
+        1`s;
+        23`s;
+        23u`m;
+        23l`h;
+        23_ul`_A_;
+        1_234_LL`__thingy_;
 
+        0xff_ffl;
+        0xff_ff`s;
+        0xff_ffu`m;
+        0xff_ffl`h;
+        0xff_fful`_A_;
+        0xff_ffLL`__thingy_;
+
+        '\n'`s;
+        L'\n'`h;
+        u'\n'`m;
+        L_'\n'`_A_;
+        U_'\n'`__thingy_;
+
+        "abc"`s;
+        u"abc"`m;
+        U_"abc"`h;
+        L"abc"`_A_;
+        u8_"abc"`__thingy_;
+} // main
 
 // Local Variables: //