Changeset 982832e


Ignore:
Timestamp:
Sep 13, 2017, 2:44:01 PM (4 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
ba54f7d, c935c3a
Parents:
e3e16bc (diff), 7dc09294 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

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

Location:
src
Files:
3 added
1 deleted
42 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    re3e16bc r982832e  
    258258
    259259        void CodeGenerator::visit( TraitDecl * traitDecl ) {
    260                 assertf( ! genC, "TraitDecl nodes should not reach code generation." );
     260                assertf( ! genC, "TraitDecls should not reach code generation." );
    261261                extension( traitDecl );
    262262                handleAggregate( traitDecl, "trait " );
     
    271271
    272272        void CodeGenerator::visit( TypeDecl * typeDecl ) {
    273                 if ( genC ) {
    274                         // really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes,
    275                         // still to be done
    276                         extension( typeDecl );
    277                         output << "extern unsigned long " << typeDecl->get_name();
    278                         if ( typeDecl->get_base() ) {
    279                                 output << " = sizeof( " << genType( typeDecl->get_base(), "", pretty, genC ) << " )";
    280                         } // if
    281                 } else {
    282                         output << typeDecl->genTypeString() << " " << typeDecl->get_name();
    283                         if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->get_sized() ) {
    284                                 output << " | sized(" << typeDecl->get_name() << ")";
    285                         }
    286                         if ( ! typeDecl->get_assertions().empty() ) {
    287                                 output << " | { ";
    288                                 genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() );
    289                                 output << " }";
    290                         }
     273                assertf( ! genC, "TypeDecls should not reach code generation." );
     274                output << typeDecl->genTypeString() << " " << typeDecl->get_name();
     275                if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->get_sized() ) {
     276                        output << " | sized(" << typeDecl->get_name() << ")";
     277                }
     278                if ( ! typeDecl->get_assertions().empty() ) {
     279                        output << " | { ";
     280                        genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() );
     281                        output << " }";
    291282                }
    292283        }
  • src/CodeGen/Generate.cc

    re3e16bc r982832e  
    3333                /// Removes misc. nodes that should not exist in CodeGen
    3434                struct TreeCleaner {
    35                         void visit( CompoundStmt * stmt );
     35                        void previsit( CompoundStmt * stmt );
    3636
    3737                        static bool shouldClean( Declaration * );
     
    7272
    7373        namespace {
    74                 void TreeCleaner::visit( CompoundStmt * cstmt ) {
     74                void TreeCleaner::previsit( CompoundStmt * cstmt ) {
    7575                        filter( cstmt->kids, [](Statement * stmt) {
    7676                                if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
  • src/Common/PassVisitor.h

    re3e16bc r982832e  
    147147        virtual Declaration* mutate( EnumDecl *aggregateDecl ) override final;
    148148        virtual Declaration* mutate( TraitDecl *aggregateDecl ) override final;
    149         virtual TypeDecl* mutate( TypeDecl *typeDecl ) override final;
     149        virtual Declaration* mutate( TypeDecl *typeDecl ) override final;
    150150        virtual Declaration* mutate( TypedefDecl *typeDecl ) override final;
    151151        virtual AsmDecl* mutate( AsmDecl *asmDecl ) override final;
  • src/Common/PassVisitor.impl.h

    re3e16bc r982832e  
    506506
    507507template< typename pass_type >
    508 TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
     508Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
    509509        MUTATE_START( node );
    510510
     
    521521        indexerScopedMutate( node->init, *this );
    522522
    523         MUTATE_END( TypeDecl, node );
     523        MUTATE_END( Declaration, node );
    524524}
    525525
  • src/Common/utility.h

    re3e16bc r982832e  
    389389}
    390390
     391// -----------------------------------------------------------------------------
     392// Helper struct and function to support
     393// for ( val : lazy_map( container1, f ) ) {}
     394// syntax to have a for each that iterates a container, mapping each element by applying f
     395template< typename T, typename Func >
     396struct lambda_iterate_t {
     397        const T & ref;
     398        std::function<Func> f;
     399
     400        struct iterator {
     401                typedef decltype(begin(ref)) Iter;
     402                Iter it;
     403                std::function<Func> f;
     404                iterator( Iter it, std::function<Func> f ) : it(it), f(f) {}
     405                iterator & operator++() {
     406                        ++it; return *this;
     407                }
     408                bool operator!=( const iterator &other ) const { return it != other.it; }
     409                auto operator*() const -> decltype(f(*it)) { return f(*it); }
     410        };
     411
     412        lambda_iterate_t( const T & ref, std::function<Func> f ) : ref(ref), f(f) {}
     413
     414        auto begin() const -> decltype(iterator(std::begin(ref), f)) { return iterator(std::begin(ref), f); }
     415        auto end() const   -> decltype(iterator(std::end(ref), f)) { return iterator(std::end(ref), f); }
     416};
     417
     418template< typename... Args >
     419lambda_iterate_t<Args...> lazy_map( const Args &... args ) {
     420        return lambda_iterate_t<Args...>( args...);
     421}
     422
     423
     424
    391425// Local Variables: //
    392426// tab-width: 4 //
  • src/GenPoly/Box.cc

    re3e16bc r982832e  
    2727
    2828#include "CodeGen/OperatorTable.h"
     29#include "Common/PassVisitor.h"          // for PassVisitor
    2930#include "Common/ScopedMap.h"            // for ScopedMap, ScopedMap<>::iter...
    3031#include "Common/SemanticError.h"        // for SemanticError
     
    157158                /// * Calculates polymorphic offsetof expressions from offset array
    158159                /// * Inserts dynamic calculation of polymorphic type layouts where needed
    159                 class PolyGenericCalculator final : public PolyMutator {
     160                class PolyGenericCalculator final : public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
    160161                public:
    161                         typedef PolyMutator Parent;
    162                         using Parent::mutate;
    163 
    164162                        PolyGenericCalculator();
    165163
    166                         template< typename DeclClass >
    167                         DeclClass *handleDecl( DeclClass *decl, Type *type );
    168                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
    169                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
    170                         virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
    171                         virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
    172                         virtual Statement *mutate( DeclStmt *declStmt ) override;
    173                         virtual Type *mutate( PointerType *pointerType ) override;
    174                         virtual Type *mutate( FunctionType *funcType ) override;
    175                         virtual Expression *mutate( MemberExpr *memberExpr ) override;
    176                         virtual Expression *mutate( SizeofExpr *sizeofExpr ) override;
    177                         virtual Expression *mutate( AlignofExpr *alignofExpr ) override;
    178                         virtual Expression *mutate( OffsetofExpr *offsetofExpr ) override;
    179                         virtual Expression *mutate( OffsetPackExpr *offsetPackExpr ) override;
    180 
    181                         virtual void doBeginScope() override;
    182                         virtual void doEndScope() override;
     164                        void premutate( ObjectDecl *objectDecl );
     165                        void premutate( FunctionDecl *functionDecl );
     166                        void premutate( TypedefDecl *objectDecl );
     167                        void premutate( TypeDecl *objectDecl );
     168                        Declaration * postmutate( TypeDecl *TraitDecl );
     169                        void premutate( PointerType *pointerType );
     170                        void premutate( FunctionType *funcType );
     171                        void premutate( DeclStmt *declStmt );
     172                        Expression *postmutate( MemberExpr *memberExpr );
     173                        Expression *postmutate( SizeofExpr *sizeofExpr );
     174                        Expression *postmutate( AlignofExpr *alignofExpr );
     175                        Expression *postmutate( OffsetofExpr *offsetofExpr );
     176                        Expression *postmutate( OffsetPackExpr *offsetPackExpr );
     177
     178                        void beginScope();
     179                        void endScope();
    183180
    184181                private:
     
    194191                        /// Exits the type-variable scope
    195192                        void endTypeScope();
     193                        /// Enters a new scope for knowLayouts and knownOffsets and queues exit calls
     194                        void beginGenericScope();
    196195
    197196                        ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
    198197                        ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
    199198                        UniqueName bufNamer;                           ///< Namer for VLA buffers
     199                        TyVarMap scopeTyVars;
    200200                };
    201201
     
    250250                Pass1 pass1;
    251251                Pass2 pass2;
    252                 PolyGenericCalculator polyCalculator;
     252                PassVisitor<PolyGenericCalculator> polyCalculator;
    253253                Pass3 pass3;
    254254
     
    256256                mutateTranslationUnit/*All*/( translationUnit, pass1 );
    257257                mutateTranslationUnit/*All*/( translationUnit, pass2 );
    258                 mutateTranslationUnit/*All*/( translationUnit, polyCalculator );
     258                mutateAll( translationUnit, polyCalculator );
    259259                mutateTranslationUnit/*All*/( translationUnit, pass3 );
    260260        }
     
    555555                TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
    556556                        addToTyVarMap( typeDecl, scopeTyVars );
    557                         return Mutator::mutate( typeDecl );
     557                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
    558558                }
    559559
     
    762762                                } else if ( arg->get_result()->get_lvalue() ) {
    763763                                        // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
     764                                        // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
     765                                        //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
     766                                        //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
     767                                        //              return;
     768                                        //      }
     769                                        // }
    764770                                        arg =  generalizedLvalue( new AddressExpr( arg ) );
    765771                                        if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
     
    13531359                                return handleDecl( typeDecl );
    13541360                        } else {
    1355                                 return Parent::mutate( typeDecl );
     1361                                return dynamic_cast<TypeDecl*>( Parent::mutate( typeDecl ) );
    13561362                        }
    13571363                }
     
    14661472
    14671473                PolyGenericCalculator::PolyGenericCalculator()
    1468                         : Parent(), knownLayouts(), knownOffsets(), bufNamer( "_buf" ) {}
     1474                        : knownLayouts(), knownOffsets(), bufNamer( "_buf" ), scopeTyVars( TypeDecl::Data{} ) {}
    14691475
    14701476                void PolyGenericCalculator::beginTypeScope( Type *ty ) {
    1471                         scopeTyVars.beginScope();
     1477                        GuardScope( scopeTyVars );
    14721478                        makeTyVarMap( ty, scopeTyVars );
    14731479                }
    14741480
    1475                 void PolyGenericCalculator::endTypeScope() {
    1476                         scopeTyVars.endScope();
    1477                 }
    1478 
    1479                 template< typename DeclClass >
    1480                 DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
    1481                         beginTypeScope( type );
    1482                         // knownLayouts.beginScope();
    1483                         // knownOffsets.beginScope();
    1484 
    1485                         DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
    1486 
    1487                         // knownOffsets.endScope();
    1488                         // knownLayouts.endScope();
    1489                         endTypeScope();
    1490                         return ret;
    1491                 }
    1492 
    1493                 ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) {
    1494                         return handleDecl( objectDecl, objectDecl->get_type() );
    1495                 }
    1496 
    1497                 DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
    1498                         knownLayouts.beginScope();
    1499                         knownOffsets.beginScope();
    1500 
    1501                         DeclarationWithType * decl = handleDecl( functionDecl, functionDecl->get_functionType() );
    1502                         knownOffsets.endScope();
    1503                         knownLayouts.endScope();
    1504                         return decl;
    1505                 }
    1506 
    1507                 TypedefDecl * PolyGenericCalculator::mutate( TypedefDecl *typedefDecl ) {
    1508                         return handleDecl( typedefDecl, typedefDecl->get_base() );
    1509                 }
    1510 
    1511                 TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
     1481                void PolyGenericCalculator::beginGenericScope() {
     1482                        GuardScope( *this );
     1483                }
     1484
     1485                void PolyGenericCalculator::premutate( ObjectDecl *objectDecl ) {
     1486                        beginTypeScope( objectDecl->get_type() );
     1487                }
     1488
     1489                void PolyGenericCalculator::premutate( FunctionDecl *functionDecl ) {
     1490                        beginGenericScope();
     1491
     1492                        beginTypeScope( functionDecl->get_functionType() );
     1493                }
     1494
     1495                void PolyGenericCalculator::premutate( TypedefDecl *typedefDecl ) {
     1496                        beginTypeScope( typedefDecl->get_base() );
     1497                }
     1498
     1499                void PolyGenericCalculator::premutate( TypeDecl * typeDecl ) {
    15121500                        addToTyVarMap( typeDecl, scopeTyVars );
    1513                         return Parent::mutate( typeDecl );
    1514                 }
    1515 
    1516                 Type * PolyGenericCalculator::mutate( PointerType *pointerType ) {
     1501                }
     1502
     1503                Declaration * PolyGenericCalculator::postmutate( TypeDecl *typeDecl ) {
     1504                        if ( Type * base = typeDecl->base ) {
     1505                                // add size/align variables for opaque type declarations
     1506                                TypeInstType inst( Type::Qualifiers(), typeDecl->name, typeDecl );
     1507                                std::string typeName = mangleType( &inst );
     1508                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
     1509
     1510                                ObjectDecl * sizeDecl = ObjectDecl::newObject( sizeofName( typeName ), layoutType, new SingleInit( new SizeofExpr( base->clone() ) ) );
     1511                                ObjectDecl * alignDecl = ObjectDecl::newObject( alignofName( typeName ), layoutType->clone(), new SingleInit( new AlignofExpr( base->clone() ) ) );
     1512
     1513                                // ensure that the initializing sizeof/alignof exprs are properly mutated
     1514                                sizeDecl->acceptMutator( *visitor );
     1515                                alignDecl->acceptMutator( *visitor );
     1516
     1517                                // can't use makeVar, because it inserts into stmtsToAdd and TypeDecls can occur at global scope
     1518                                declsToAddAfter.push_back( alignDecl );
     1519                                // replace with sizeDecl
     1520                                return sizeDecl;
     1521                        }
     1522                        return typeDecl;
     1523                }
     1524
     1525                void PolyGenericCalculator::premutate( PointerType *pointerType ) {
    15171526                        beginTypeScope( pointerType );
    1518 
    1519                         Type *ret = Parent::mutate( pointerType );
    1520 
    1521                         endTypeScope();
    1522                         return ret;
    1523                 }
    1524 
    1525                 Type * PolyGenericCalculator::mutate( FunctionType *funcType ) {
     1527                }
     1528
     1529                void PolyGenericCalculator::premutate( FunctionType *funcType ) {
    15261530                        beginTypeScope( funcType );
    15271531
     
    15341538                                }
    15351539                        }
    1536 
    1537                         Type *ret = Parent::mutate( funcType );
    1538 
    1539                         endTypeScope();
    1540                         return ret;
    1541                 }
    1542 
    1543                 Statement *PolyGenericCalculator::mutate( DeclStmt *declStmt ) {
     1540                }
     1541
     1542                void PolyGenericCalculator::premutate( DeclStmt *declStmt ) {
    15441543                        if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
    15451544                                if ( findGeneric( objectDecl->get_type() ) ) {
     
    15501549                                                new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Kind::Char), new NameExpr( sizeofName( mangleType(declType) ) ),
    15511550                                                true, false, std::list<Attribute*>{ new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } ) } ), 0 );
    1552                                         stmtsToAdd.push_back( new DeclStmt( noLabels, newBuf ) );
     1551                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) );
    15531552
    15541553                                        delete objectDecl->get_init();
     
    15561555                                }
    15571556                        }
    1558                         return Parent::mutate( declStmt );
    15591557                }
    15601558
     
    15831581                }
    15841582
    1585                 Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
    1586                         // mutate, exiting early if no longer MemberExpr
    1587                         Expression *expr = Parent::mutate( memberExpr );
    1588                         memberExpr = dynamic_cast< MemberExpr* >( expr );
    1589                         if ( ! memberExpr ) return expr;
    1590 
     1583                Expression *PolyGenericCalculator::postmutate( MemberExpr *memberExpr ) {
    15911584                        // only mutate member expressions for polymorphic types
    15921585                        int tyDepth;
     
    16351628                ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
    16361629                        ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
    1637                         stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
     1630                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
    16381631                        return newObj;
    16391632                }
     
    17141707                                        addOtypeParamsToLayoutCall( layoutCall, otypeParams );
    17151708
    1716                                         stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
     1709                                        stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
    17171710                                }
    17181711
     
    17401733                                addOtypeParamsToLayoutCall( layoutCall, otypeParams );
    17411734
    1742                                 stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
     1735                                stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
    17431736
    17441737                                return true;
     
    17481741                }
    17491742
    1750                 Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
     1743                Expression *PolyGenericCalculator::postmutate( SizeofExpr *sizeofExpr ) {
    17511744                        Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
    17521745                        if ( findGeneric( ty ) ) {
     
    17581751                }
    17591752
    1760                 Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
     1753                Expression *PolyGenericCalculator::postmutate( AlignofExpr *alignofExpr ) {
    17611754                        Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result();
    17621755                        if ( findGeneric( ty ) ) {
     
    17681761                }
    17691762
    1770                 Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) {
    1771                         // mutate, exiting early if no longer OffsetofExpr
    1772                         Expression *expr = Parent::mutate( offsetofExpr );
    1773                         offsetofExpr = dynamic_cast< OffsetofExpr* >( expr );
    1774                         if ( ! offsetofExpr ) return expr;
    1775 
     1763                Expression *PolyGenericCalculator::postmutate( OffsetofExpr *offsetofExpr ) {
    17761764                        // only mutate expressions for polymorphic structs/unions
    17771765                        Type *ty = offsetofExpr->get_type();
     
    17931781                }
    17941782
    1795                 Expression *PolyGenericCalculator::mutate( OffsetPackExpr *offsetPackExpr ) {
     1783                Expression *PolyGenericCalculator::postmutate( OffsetPackExpr *offsetPackExpr ) {
    17961784                        StructInstType *ty = offsetPackExpr->get_type();
    17971785
     
    18321820                }
    18331821
    1834                 void PolyGenericCalculator::doBeginScope() {
     1822                void PolyGenericCalculator::beginScope() {
    18351823                        knownLayouts.beginScope();
    18361824                        knownOffsets.beginScope();
    18371825                }
    18381826
    1839                 void PolyGenericCalculator::doEndScope() {
     1827                void PolyGenericCalculator::endScope() {
    18401828                        knownLayouts.endScope();
    18411829                        knownOffsets.endScope();
     
    18941882
    18951883                        addToTyVarMap( typeDecl, scopeTyVars );
    1896                         return Mutator::mutate( typeDecl );
     1884                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
    18971885                }
    18981886
  • src/Parser/DeclarationNode.cc

    re3e16bc r982832e  
    333333DeclarationNode * DeclarationNode::newTypeDecl( string * name, DeclarationNode * typeParams ) {
    334334        DeclarationNode * newnode = new DeclarationNode;
     335        newnode->name = name;
    335336        newnode->type = new TypeData( TypeData::Symbolic );
    336337        newnode->type->symbolic.isTypedef = false;
    337338        newnode->type->symbolic.params = typeParams;
    338         newnode->type->symbolic.name = name;
    339339        return newnode;
    340340} // DeclarationNode::newTypeDecl
  • src/Parser/ExpressionNode.cc

    re3e16bc r982832e  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Sep  3 22:21:21 2017
    13 // Update Count     : 639
     12// Last Modified On : Tue Sep 12 10:00:29 2017
     13// Update Count     : 672
    1414//
    1515
     
    4949// type.
    5050
    51 extern const Type::Qualifiers noQualifiers;             // no qualifiers on constants
    52 
     51extern const Type::Qualifiers noQualifiers;                             // no qualifiers on constants
     52
     53static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
     54static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
     55static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; }
    5356static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
    54 static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
    5557static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
    5658static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
     
    6769
    6870Expression * build_constantInteger( string & str ) {
    69         static const BasicType::Kind kind[2][3] = {
    70                 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
    71                 { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
     71        static const BasicType::Kind kind[2][5] = {
     72                // short (h) must be before char (hh)
     73                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
     74                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
    7275        };
    7376
     
    7679
    7780        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
    78         int size;                                                                                       // 0 => int, 1 => long, 2 => long long
     81        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => size_t
    7982        unsigned long long int v;                                                       // converted integral value
    8083        size_t last = str.length() - 1;                                         // last character of constant
    8184        Expression * ret;
    8285
    83         // ROB: what do we do with units on 0 and 1?
    8486        // special constants
    8587        if ( str == "0" ) {
     
    107109
    108110        if ( v <= INT_MAX ) {                                                           // signed int
    109                 size = 0;
     111                size = 2;
    110112        } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
    111                 size = 0;
     113                size = 2;
    112114                Unsigned = true;                                                                // unsigned
    113115        } else if ( v <= LONG_MAX ) {                                           // signed long int
    114                 size = 1;
     116                size = 3;
    115117        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
    116                 size = 1;
     118                size = 3;
    117119                Unsigned = true;                                                                // unsigned long int
    118120        } else if ( v <= LLONG_MAX ) {                                          // signed long long int
    119                 size = 2;
     121                size = 4;
    120122        } else {                                                                                        // unsigned long long int
    121                 size = 2;
     123                size = 4;
    122124                Unsigned = true;                                                                // unsigned long long int
    123125        } // if
     126
     127        // At least one digit in integer constant, so safe to backup while looking for suffix.
    124128
    125129        if ( checkU( str[last] ) ) {                                            // suffix 'u' ?
    126130                Unsigned = true;
    127                 if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'l' ?
    128                         size = 1;
    129                         if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ?
    130                                 size = 2;
     131                if ( checkL( str[last - 1] ) ) {                                // suffix 'l' ?
     132                        size = 3;
     133                        if ( checkL( str[last - 2] ) ) {                        // suffix "ll" ?
     134                                size = 4;
    131135                        } // if
     136                } else if ( checkH( str[last - 1] ) ) {                 // suffix 'h' ?
     137                        size = 0;
     138                        if ( checkH( str[last - 2] ) ) {                        // suffix "hh" ?
     139                                size = 1;
     140                        } // if
     141                        str.erase( last - size - 1, size + 1 );         // remove 'h'/"hh"
    132142                } // if
    133143        } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
    134                 size = 1;
    135                 if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'll' ?
    136                         size = 2;
    137                         if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ?
     144                size = 3;
     145                if ( checkL( str[last - 1] ) ) {                                // suffix 'll' ?
     146                        size = 4;
     147                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
    138148                                Unsigned = true;
    139149                        } // if
    140                 } else {
    141                         if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ?
     150                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
     151                        Unsigned = true;
     152                } // if
     153        } else if ( checkH( str[ last ] ) ) {                           // suffix 'h' ?
     154                size = 0;
     155                if ( checkH( str[last - 1] ) ) {                                // suffix "hh" ?
     156                        size = 1;
     157                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
    142158                                Unsigned = true;
    143159                        } // if
    144                 } // if
     160                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
     161                        Unsigned = true;
     162                } // if
     163                str.erase( last - size, size + 1 );                             // remove 'h'/"hh"
     164        } else if ( checkZ( str[last] ) ) {                                     // suffix 'z' ?
     165                size = 5;
     166                str.erase( last, 1 );                                                   // remove 'z'
    145167        } // if
    146168
    147169        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
     170        if ( Unsigned && size < 2 ) {                                           // less than int ?
     171                // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which eliminates warnings for large values.
     172                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
     173        } else if ( size == 5 ) {                                                       // explicit cast to size_t
     174                ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), "size_t", false ) );
     175        } // if
    148176  CLEANUP:
    149177        if ( units.length() != 0 ) {
     
    247275} // build_constantStr
    248276
     277Expression * build_field_name_FLOATING_FRACTIONconstant( const string & str ) {
     278        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
     279        Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
     280        delete &str;
     281        return ret;
     282} // build_field_name_FLOATING_FRACTIONconstant
     283
     284Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
     285        if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
     286        Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
     287        delete &str;
     288        return ret;
     289} // build_field_name_FLOATING_DECIMALconstant
     290
    249291Expression * build_field_name_FLOATINGconstant( const string & str ) {
    250292        // str is of the form A.B -> separate at the . and return member expression
     
    273315        return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) );
    274316} // build_field_name_fraction_constants
    275 
    276 Expression * build_field_name_REALFRACTIONconstant( const string & str ) {
    277         if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
    278         Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
    279         delete &str;
    280         return ret;
    281 } // build_field_name_REALFRACTIONconstant
    282 
    283 Expression * build_field_name_REALDECIMALconstant( const string & str ) {
    284         if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
    285         Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
    286         delete &str;
    287         return ret;
    288 } // build_field_name_REALDECIMALconstant
    289317
    290318NameExpr * build_varref( const string * name ) {
  • src/Parser/ParseNode.h

    re3e16bc r982832e  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Sep  3 19:24:34 2017
    13 // Update Count     : 799
     12// Last Modified On : Sun Sep 10 09:56:32 2017
     13// Update Count     : 801
    1414//
    1515
     
    166166Expression * build_constantChar( std::string &str );
    167167Expression * build_constantStr( std::string &str );
     168Expression * build_field_name_FLOATING_FRACTIONconstant( const std::string & str );
     169Expression * build_field_name_FLOATING_DECIMALconstant( const std::string & str );
    168170Expression * build_field_name_FLOATINGconstant( const std::string & str );
    169171Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
    170 Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
    171 Expression * build_field_name_REALDECIMALconstant( const std::string & str );
    172172
    173173NameExpr * build_varref( const std::string * name );
  • src/Parser/lex.ll

    re3e16bc r982832e  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Thu Aug 31 21:30:10 2017
    13  * Update Count     : 598
     12 * Last Modified On : Sun Sep 10 22:29:15 2017
     13 * Update Count     : 620
    1414 */
    1515
     
    9393                                // numeric constants, CFA: '_' in constant
    9494hex_quad {hex}("_"?{hex}){3}
    95 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]?))))?
     95length ("ll"|"LL"|[lL])|("hh"|"HH"|[hH])
     96integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?{user_suffix_opt}
    9697
    9798octal_digits ({octal})|({octal}({octal}|"_")*{octal})
    9899octal_prefix "0""_"?
    99 octal_constant (("0")|({octal_prefix}{octal_digits})){integer_suffix_opt}{user_suffix_opt}
     100octal_constant (("0")|({octal_prefix}{octal_digits})){integer_suffix_opt}
    100101
    101102nonzero_digits ({nonzero})|({nonzero}({decimal}|"_")*{decimal})
    102 decimal_constant {nonzero_digits}{integer_suffix_opt}{user_suffix_opt}
     103decimal_constant {nonzero_digits}{integer_suffix_opt}
    103104
    104105hex_digits ({hex})|({hex}({hex}|"_")*{hex})
    105106hex_prefix "0"[xX]"_"?
    106 hex_constant {hex_prefix}{hex_digits}{integer_suffix_opt}{user_suffix_opt}
     107hex_constant {hex_prefix}{hex_digits}{integer_suffix_opt}
    107108
    108109                                // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
    109 floating_suffix_opt ("_"?([fFdDlL][iI]?|[iI][lLfFdD]?|"DL"))?
     110exponent "_"?[eE]"_"?[+-]?{decimal_digits}
     111floating_suffix ([fFdDlL]?[iI]?)|([iI][lLfFdD])
     112floating_suffix_opt ("_"?({floating_suffix}|"DL"))?{user_suffix_opt}
    110113decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
    111 real_decimal {decimal_digits}"."{exponent}?{floating_suffix_opt}{user_suffix_opt}
    112 real_fraction "."{decimal_digits}{exponent}?{floating_suffix_opt}{user_suffix_opt}
    113 real_constant {decimal_digits}{real_fraction}
    114 exponent "_"?[eE]"_"?[+-]?{decimal_digits}
    115 floating_constant (({real_constant}{exponent}?)|({decimal_digits}{exponent})){floating_suffix_opt}{user_suffix_opt}
     114floating_decimal {decimal_digits}"."{exponent}?{floating_suffix_opt}
     115floating_fraction "."{decimal_digits}{exponent}?{floating_suffix_opt}
     116floating_constant ({decimal_digits}{exponent}{floating_suffix_opt})|({decimal_digits}{floating_fraction})
    116117
    117118binary_exponent "_"?[pP]"_"?[+-]?{decimal_digits}
    118 hex_fractional_constant ({hex_digits}?"."{hex_digits})|({hex_digits}".")
    119 hex_floating_constant {hex_prefix}(({hex_fractional_constant}{binary_exponent})|({hex_digits}{binary_exponent})){floating_suffix_opt}
     119hex_floating_suffix_opt ("_"?({floating_suffix}))?{user_suffix_opt}
     120hex_floating_fraction ({hex_digits}?"."{hex_digits})|({hex_digits}".")
     121hex_floating_constant {hex_prefix}(({hex_floating_fraction}{binary_exponent})|({hex_digits}{binary_exponent})){hex_floating_suffix_opt}
    120122
    121123                                // character escape sequence, GCC: \e => esc character
    122124simple_escape "\\"[abefnrtv'"?\\]
    123                                 // ' stop highlighting
     125                                // ' stop editor highlighting
    124126octal_escape "\\"{octal}("_"?{octal}){0,2}
    125127hex_escape "\\""x""_"?{hex_digits}
     
    154156                                /* line directives */
    155157^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["].*"\n" {
    156         /* " stop highlighting */
     158        /* " stop editor highlighting */
    157159        static char filename[FILENAME_MAX];                                     // temporarily store current source-file name
    158160        char *end_num;
     
    310312{octal_constant} { NUMERIC_RETURN(INTEGERconstant); }
    311313{hex_constant}  { NUMERIC_RETURN(INTEGERconstant); }
    312 {real_decimal}  { NUMERIC_RETURN(REALDECIMALconstant); } // must appear before floating_constant
    313 {real_fraction} { NUMERIC_RETURN(REALFRACTIONconstant); } // must appear before floating_constant
     314{floating_decimal}      { NUMERIC_RETURN(FLOATING_DECIMALconstant); } // must appear before floating_constant
     315{floating_fraction}     { NUMERIC_RETURN(FLOATING_FRACTIONconstant); } // must appear before floating_constant
    314316{floating_constant}     { NUMERIC_RETURN(FLOATINGconstant); }
    315317{hex_floating_constant} { NUMERIC_RETURN(FLOATINGconstant); }
     
    319321<QUOTE>[^'\\\n]* { strtext->append( yytext, yyleng ); }
    320322<QUOTE>['\n]{user_suffix_opt}   { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); }
    321                                 /* ' stop highlighting */
     323                                /* ' stop editor highlighting */
    322324
    323325                                /* string constant */
     
    325327<STRING>[^"\\\n]* { strtext->append( yytext, yyleng ); }
    326328<STRING>["\n]{user_suffix_opt}  { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); }
    327                                 /* " stop highlighting */
     329                                /* " stop editor highlighting */
    328330
    329331                                /* common character/string constant */
  • src/Parser/parser.yy

    re3e16bc r982832e  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Sep  3 20:43:19 2017
    13 // Update Count     : 2742
     12// Last Modified On : Mon Sep 11 18:12:00 2017
     13// Update Count     : 2787
    1414//
    1515
     
    4343#define YYDEBUG_LEXER_TEXT (yylval)                                             // lexer loads this up each time
    4444#define YYDEBUG 1                                                                               // get the pretty debugging code to compile
     45#define YYERROR_VERBOSE
    4546
    4647#undef __GNUC_MINOR__
     
    6263stack< LinkageSpec::Spec > linkageStack;
    6364
    64 void appendStr( string *to, string *from ) {
    65         // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
    66         to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) );
     65bool appendStr( string & to, string & from ) {
     66        // 1. Multiple strings are concatenated into a single string but not combined internally. The reason is that
     67        //    "\x12" "3" is treated as 2 characters versus 1 because "escape sequences are converted into single members of
     68        //    the execution character set just prior to adjacent string literal concatenation" (C11, Section 6.4.5-8). It is
     69        //    easier to let the C compiler handle this case.
     70        //
     71        // 2. String encodings are transformed into canonical form (one encoding at start) so the encoding can be found
     72        //    without searching the string, e.g.: "abc" L"def" L"ghi" => L"abc" "def" "ghi". Multiple encodings must match,
     73        //    i.e., u"a" U"b" L"c" is disallowed.
     74
     75        if ( from[0] != '"' ) {                                                         // encoding ?
     76                if ( to[0] != '"' ) {                                                   // encoding ?
     77                        if ( to[0] != from[0] || to[1] != from[1] ) { // different encodings ?
     78                                yyerror( "non-matching string encodings for string-literal concatenation" );
     79                                return false;                                                   // parse error, must call YYERROR in action
     80                        } else if ( from[1] == '8' ) {
     81                                from.erase( 0, 1 );                                             // remove 2nd encoding
     82                        } // if
     83                } else {
     84                        if ( from[1] == '8' ) {                                         // move encoding to start
     85                                to = "u8" + to;
     86                                from.erase( 0, 1 );                                             // remove 2nd encoding
     87                        } else {
     88                                to = from[0] + to;
     89                        } // if
     90                } // if
     91                from.erase( 0, 1 );                                                             // remove 2nd encoding
     92        } // if
     93        to += " " + from;                                                                       // concatenated into single string
     94        return true;
    6795} // appendStr
    6896
     
    88116bool forall = false;                                                                    // aggregate have one or more forall qualifiers ?
    89117%}
     118
     119%define parse.error verbose
    90120
    91121// Types declaration
     
    146176// overloading constants 0/1, e.g., x.1 is lexed as (x)(.1), where (.1) is a factional constant, but is semantically
    147177// converted into the tuple index (.)(1). e.g., 3.x
    148 %token<tok>     REALDECIMALconstant     REALFRACTIONconstant    FLOATINGconstant
     178%token<tok>     FLOATING_DECIMALconstant        FLOATING_FRACTIONconstant       FLOATINGconstant
    149179
    150180// multi-character operators
     
    315345%precedence ELSE        // token precedence for start of else clause in IF/WAITFOR statement
    316346
     347
    317348%start translation_unit                                                                 // parse-tree root
    318349
     
    321352
    322353// The grammar in the ANSI C standard is not strictly context-free, since it relies upon the distinct terminal symbols
    323 // "identifier" and "TYPEDEFname" that are lexically identical.  While it is possible to write a purely context-free
    324 // grammar, such a grammar would obscure the relationship between syntactic and semantic constructs.  Hence, this
    325 // grammar uses the ANSI style.
     354// "identifier", "TYPEDEFname", and "TYPEGENname" that are lexically identical.  While it is possible to write a purely
     355// context-free grammar, such a grammar would obscure the relationship between syntactic and semantic constructs.
     356// Hence, this grammar uses the ANSI style.
    326357//
    327358// Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance, those
     
    360391                // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
    361392        INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
    362         | REALDECIMALconstant                                           { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
    363         | REALFRACTIONconstant                                          { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
     393        | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
     394        | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
    364395        | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
    365396        | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( *$1 ) ); }
     
    390421        | string_literal_list STRINGliteral
    391422                {
    392                         appendStr( $1, $2 );                                            // append 2nd juxtaposed string to 1st
     423                        if ( ! appendStr( *$1, *$2 ) ) YYERROR;         // append 2nd juxtaposed string to 1st
    393424                        delete $2;                                                                      // allocated by lexer
    394425                        $$ = $1;                                                                        // conversion from tok to str
     
    434465        | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
    435466                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
    436         | postfix_expression REALFRACTIONconstant                       // CFA, tuple index
    437                 { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_REALFRACTIONconstant( *$2 ) ) ); }
     467        | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
     468                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
    438469        | postfix_expression ARROW no_attr_identifier
    439470                {
     
    479510field:                                                                                                  // CFA, tuple field selector
    480511        field_name
    481         | REALDECIMALconstant field
    482                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
    483         | REALDECIMALconstant '[' push field_list pop ']'
    484                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *$1 ) ), build_tuple( $4 ) ) ); }
     512        | FLOATING_DECIMALconstant field
     513                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
     514        | FLOATING_DECIMALconstant '[' push field_list pop ']'
     515                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $4 ) ) ); }
    485516        | field_name '.' field
    486517                { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
     
    507538        // empty
    508539                { $$ = nullptr; }
    509         | fraction_constants REALFRACTIONconstant
    510                 {
    511                         Expression * constant = build_field_name_REALFRACTIONconstant( *$2 );
     540        | fraction_constants FLOATING_FRACTIONconstant
     541                {
     542                        Expression * constant = build_field_name_FLOATING_FRACTIONconstant( *$2 );
    512543                        $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( $1,  constant ) ) : new ExpressionNode( constant );
    513544                }
  • src/ResolvExpr/CastCost.cc

    re3e16bc r982832e  
    4545                                }
    4646                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
    47                                 TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    4847                                // all typedefs should be gone by this point
    49                                 assert( type );
     48                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
    5049                                if ( type->get_base() ) {
    5150                                        return castCost( src, type->get_base(), indexer, env ) + Cost::safe;
  • src/ResolvExpr/ConversionCost.cc

    re3e16bc r982832e  
    9292
    9393        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
    94                 PRINT( std::cerr << "convert to reference cost..." << std::endl; )
     94                PRINT( std::cerr << "convert to reference cost... diff " << diff << std::endl; )
    9595                if ( diff > 0 ) {
    9696                        // TODO: document this
     
    128128                        ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
    129129                        assert( diff == -1 && destAsRef );
     130                        PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; )
    130131                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
    131132                                PRINT( std::cerr << "converting compatible base type" << std::endl; )
  • src/SymTab/Autogen.cc

    re3e16bc r982832e  
    163163                // Routines at global scope marked "static" to prevent multiple definitions in separate translation units
    164164                // because each unit generates copies of the default routines for each aggregate.
    165 //              DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static;
    166165                Type::StorageClasses scs = functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static );
    167166                LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen;
     
    186185        /// using map and t, determines if is constructable, etc.
    187186        bool lookup( const TypeMap & map, Type * t ) {
     187                assertf( t, "Autogenerate lookup was given non-type: %s", toString( t ).c_str() );
    188188                if ( dynamic_cast< PointerType * >( t ) ) {
    189189                        // will need more complicated checking if we want this to work with pointer types, since currently
     
    200200
    201201        /// using map and aggr, examines each member to determine if constructor, etc. should be generated
    202         template<typename AggrDecl>
    203         bool shouldGenerate( const TypeMap & map, AggrDecl * aggr ) {
    204                 for ( Declaration * dcl : aggr->get_members() ) {
    205                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( dcl ) ) {
    206                                 if ( ! lookup( map, dwt->get_type() ) ) return false;
    207                         }
     202        template<typename Container>
     203        bool shouldGenerate( const TypeMap & map, const Container & container ) {
     204                for ( Type * t : container ) {
     205                        if ( ! lookup( map, t ) ) return false;
    208206                }
    209207                return true;
     
    211209
    212210        /// data structure for abstracting the generation of special functions
    213         template< typename OutputIterator >
     211        template< typename OutputIterator, typename Container >
    214212        struct FuncGenerator {
    215                 StructDecl *aggregateDecl;
    216                 StructInstType *refType;
     213                const Container & container;
     214                Type *refType;
    217215                unsigned int functionNesting;
    218216                const std::list< TypeDecl* > & typeParams;
    219217                OutputIterator out;
    220                 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 ) {}
     218                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 ) {}
    221219
    222220                /// generates a function (?{}, ?=?, ^?{}) based on the data argument and members. If function is generated, inserts the type into the map.
    223221                void gen( const FuncData & data, bool concurrent_type ) {
    224                         if ( ! shouldGenerate( data.map, aggregateDecl ) ) return;
     222                        if ( ! shouldGenerate( data.map, container ) ) return;
    225223                        FunctionType * ftype = data.genType( refType );
    226224
    227225                        if(concurrent_type && CodeGen::isDestructor( data.fname )) {
    228                                 ftype->get_parameters().front()->get_type()->set_mutex( true );
    229                         }
    230 
    231                         cloneAll( typeParams, ftype->get_forall() );
     226                                ftype->parameters.front()->get_type()->set_mutex( true );
     227                        }
     228
     229                        cloneAll( typeParams, ftype->forall );
    232230                        *out++ = genFunc( data.fname, ftype, functionNesting );
    233231                        data.map.insert( Mangler::mangleType( refType ), true );
     
    235233        };
    236234
    237         template< typename OutputIterator >
    238         FuncGenerator<OutputIterator> makeFuncGenerator( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) {
    239                 return FuncGenerator<OutputIterator>( aggregateDecl, refType, functionNesting, typeParams, out );
     235        template< typename OutputIterator, typename Container >
     236        FuncGenerator<OutputIterator, Container> makeFuncGenerator( const Container & container, Type *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) {
     237                return FuncGenerator<OutputIterator, Container>( container, refType, functionNesting, typeParams, out );
    240238        }
    241239
     
    393391        }
    394392
     393        Type * declToType( Declaration * decl ) {
     394                if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
     395                        return dwt->get_type();
     396                }
     397                return nullptr;
     398        }
     399
    395400        /// generates struct constructors, destructor, and assignment functions
    396401        void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
     
    406411                // generate each of the functions based on the supplied FuncData objects
    407412                std::list< FunctionDecl * > newFuncs;
    408                 auto generator = makeFuncGenerator( aggregateDecl, refType, functionNesting, typeParams, back_inserter( newFuncs ) );
     413                // structure that iterates aggregate decl members, returning their types
     414                auto generator = makeFuncGenerator( lazy_map( aggregateDecl->members, declToType ), refType, functionNesting, typeParams, back_inserter( newFuncs ) );
    409415                for ( const FuncData & d : data ) {
    410416                        generator.gen( d, aggregateDecl->is_thread() || aggregateDecl->is_monitor() );
     
    605611        }
    606612
     613        Type * declToTypeDeclBase( Declaration * decl ) {
     614                if ( TypeDecl * td = dynamic_cast< TypeDecl * >( decl ) ) {
     615                        return td->base;
     616                }
     617                return nullptr;
     618        }
     619
     620        // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
    607621        void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
    608                 TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
    609                 typeInst->set_baseType( typeDecl );
    610                 ObjectDecl *src = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr );
    611                 ObjectDecl *dst = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr );
    612 
    613                 std::list< Statement * > stmts;
    614                 if ( typeDecl->get_base() ) {
    615                         // xxx - generate ctor/dtors for typedecls, e.g.
    616                         // otype T = int *;
    617                         UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
    618                         assign->get_args().push_back( new CastExpr( new VariableExpr( dst ), new PointerType( Type::Qualifiers(), typeDecl->get_base()->clone() ) ) );
    619                         assign->get_args().push_back( new CastExpr( new VariableExpr( src ), typeDecl->get_base()->clone() ) );
    620                         stmts.push_back( new ReturnStmt( std::list< Label >(), assign ) );
    621                 } // if
    622                 FunctionType *type = new FunctionType( Type::Qualifiers(), false );
    623                 type->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, typeInst, 0 ) );
    624                 type->get_parameters().push_back( dst );
    625                 type->get_parameters().push_back( src );
    626                 FunctionDecl *func = genFunc( "?=?", type, functionNesting );
    627                 func->get_statements()->get_kids() = stmts;
    628                 declsToAddAfter.push_back( func );
     622                if ( ! typeDecl->base ) return;
     623
     624                // generate each of the functions based on the supplied FuncData objects
     625                std::list< FunctionDecl * > newFuncs;
     626                std::list< Declaration * > tds { typeDecl };
     627                std::list< TypeDecl * > typeParams;
     628                TypeInstType refType( Type::Qualifiers(), typeDecl->name, typeDecl );
     629                auto generator = makeFuncGenerator( lazy_map( tds, declToTypeDeclBase ), &refType, functionNesting, typeParams, back_inserter( newFuncs ) );
     630                for ( const FuncData & d : data ) {
     631                        generator.gen( d, false );
     632                }
     633
     634                if ( functionNesting == 0 ) {
     635                        // forward declare if top-level struct, so that
     636                        // type is complete as soon as its body ends
     637                        // Note: this is necessary if we want structs which contain
     638                        // generic (otype) structs as members.
     639                        for ( FunctionDecl * dcl : newFuncs ) {
     640                                addForwardDecl( dcl, declsToAddAfter );
     641                        }
     642                }
     643
     644                for ( FunctionDecl * dcl : newFuncs ) {
     645                        FunctionType * ftype = dcl->type;
     646                        assertf( ftype->parameters.size() == 1 || ftype->parameters.size() == 2, "Incorrect number of parameters in autogenerated typedecl function: %zd", ftype->parameters.size() );
     647                        DeclarationWithType * dst = ftype->parameters.front();
     648                        DeclarationWithType * src = ftype->parameters.size() == 2 ? ftype->parameters.back() : nullptr;
     649                        // generate appropriate calls to member ctor, assignment
     650                        // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor
     651                        UntypedExpr * expr = new UntypedExpr( new NameExpr( dcl->name ) );
     652                        expr->args.push_back( new CastExpr( new VariableExpr( dst ), new ReferenceType( Type::Qualifiers(), typeDecl->base->clone() ) ) );
     653                        if ( src ) expr->args.push_back( new CastExpr( new VariableExpr( src ), typeDecl->base->clone() ) );
     654                        dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) );
     655                        if ( CodeGen::isAssignment( dcl->get_name() ) ) {
     656                                // assignment needs to return a value
     657                                FunctionType * assignType = dcl->type;
     658                                assert( assignType->parameters.size() == 2 );
     659                                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.back() );
     660                                dcl->statements->kids.push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
     661                        }
     662                        declsToAddAfter.push_back( dcl );
     663                }
    629664        }
    630665
  • src/SymTab/Validate.cc

    re3e16bc r982832e  
    176176        };
    177177
    178         class EliminateTypedef : public Mutator {
    179           public:
     178        struct EliminateTypedef final : public WithVisitorRef<EliminateTypedef>, public WithGuards {
    180179                EliminateTypedef() : scopeLevel( 0 ) {}
    181180                /// Replaces typedefs by forward declarations
    182181                static void eliminateTypedef( std::list< Declaration * > &translationUnit );
     182
     183                Type * postmutate( TypeInstType * aggregateUseType );
     184                Declaration * postmutate( TypedefDecl * typeDecl );
     185                void premutate( TypeDecl * typeDecl );
     186                void premutate( FunctionDecl * funcDecl );
     187                void premutate( ObjectDecl * objDecl );
     188                DeclarationWithType * postmutate( ObjectDecl * objDecl );
     189
     190                void premutate( CastExpr * castExpr );
     191
     192                void premutate( CompoundStmt * compoundStmt );
     193                CompoundStmt * postmutate( CompoundStmt * compoundStmt );
     194
     195                void premutate( StructDecl * structDecl );
     196                Declaration * postmutate( StructDecl * structDecl );
     197                void premutate( UnionDecl * unionDecl );
     198                Declaration * postmutate( UnionDecl * unionDecl );
     199                void premutate( EnumDecl * enumDecl );
     200                Declaration * postmutate( EnumDecl * enumDecl );
     201                Declaration * postmutate( TraitDecl * contextDecl );
     202
    183203          private:
    184                 virtual Declaration *mutate( TypedefDecl *typeDecl );
    185                 virtual TypeDecl *mutate( TypeDecl *typeDecl );
    186                 virtual DeclarationWithType *mutate( FunctionDecl *funcDecl );
    187                 virtual DeclarationWithType *mutate( ObjectDecl *objDecl );
    188                 virtual CompoundStmt *mutate( CompoundStmt *compoundStmt );
    189                 virtual Type *mutate( TypeInstType *aggregateUseType );
    190                 virtual Expression *mutate( CastExpr *castExpr );
    191 
    192                 virtual Declaration *mutate( StructDecl * structDecl );
    193                 virtual Declaration *mutate( UnionDecl * unionDecl );
    194                 virtual Declaration *mutate( EnumDecl * enumDecl );
    195                 virtual Declaration *mutate( TraitDecl * contextDecl );
    196 
    197204                template<typename AggDecl>
    198205                AggDecl *handleAggregate( AggDecl * aggDecl );
     
    667674
    668675        void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
    669                 EliminateTypedef eliminator;
     676                PassVisitor<EliminateTypedef> eliminator;
    670677                mutateAll( translationUnit, eliminator );
    671                 if ( eliminator.typedefNames.count( "size_t" ) ) {
     678                if ( eliminator.pass.typedefNames.count( "size_t" ) ) {
    672679                        // grab and remember declaration of size_t
    673                         SizeType = eliminator.typedefNames["size_t"].first->get_base()->clone();
     680                        SizeType = eliminator.pass.typedefNames["size_t"].first->get_base()->clone();
    674681                } else {
    675682                        // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
     
    681688        }
    682689
    683         Type *EliminateTypedef::mutate( TypeInstType * typeInst ) {
     690        Type * EliminateTypedef::postmutate( TypeInstType * typeInst ) {
    684691                // instances of typedef types will come here. If it is an instance
    685692                // of a typdef type, link the instance to its actual type.
     
    696703                                rtt->get_parameters().clear();
    697704                                cloneAll( typeInst->get_parameters(), rtt->get_parameters() );
    698                                 mutateAll( rtt->get_parameters(), *this );  // recursively fix typedefs on parameters
     705                                mutateAll( rtt->get_parameters(), *visitor );  // recursively fix typedefs on parameters
    699706                        } // if
    700707                        delete typeInst;
     
    708715        }
    709716
    710         Declaration *EliminateTypedef::mutate( TypedefDecl * tyDecl ) {
    711                 Declaration *ret = Mutator::mutate( tyDecl );
    712 
     717        Declaration *EliminateTypedef::postmutate( TypedefDecl * tyDecl ) {
    713718                if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
    714719                        // typedef to the same name from the same scope
     
    741746                        return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() );
    742747                } else {
    743                         return ret->clone();
    744                 } // if
    745         }
    746 
    747         TypeDecl *EliminateTypedef::mutate( TypeDecl * typeDecl ) {
     748                        return tyDecl->clone();
     749                } // if
     750        }
     751
     752        void EliminateTypedef::premutate( TypeDecl * typeDecl ) {
    748753                TypedefMap::iterator i = typedefNames.find( typeDecl->get_name() );
    749754                if ( i != typedefNames.end() ) {
     
    752757
    753758                typedeclNames[ typeDecl->get_name() ] = typeDecl;
    754                 return Mutator::mutate( typeDecl );
    755         }
    756 
    757         DeclarationWithType *EliminateTypedef::mutate( FunctionDecl * funcDecl ) {
    758                 typedefNames.beginScope();
    759                 DeclarationWithType *ret = Mutator::mutate( funcDecl );
    760                 typedefNames.endScope();
    761                 return ret;
    762         }
    763 
    764         DeclarationWithType *EliminateTypedef::mutate( ObjectDecl * objDecl ) {
    765                 typedefNames.beginScope();
    766                 DeclarationWithType *ret = Mutator::mutate( objDecl );
    767                 typedefNames.endScope();
    768 
    769                 if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) { // function type?
     759        }
     760
     761        void EliminateTypedef::premutate( FunctionDecl * ) {
     762                GuardScope( typedefNames );
     763        }
     764
     765        void EliminateTypedef::premutate( ObjectDecl * ) {
     766                GuardScope( typedefNames );
     767        }
     768
     769        DeclarationWithType *EliminateTypedef::postmutate( ObjectDecl * objDecl ) {
     770                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->get_type() ) ) { // function type?
    770771                        // replace the current object declaration with a function declaration
    771                         FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClasses(), ret->get_linkage(), funtype, 0, objDecl->get_attributes(), ret->get_funcSpec() );
     772                        FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() );
    772773                        objDecl->get_attributes().clear();
    773774                        objDecl->set_type( nullptr );
     
    775776                        return newDecl;
    776777                } // if
    777                 return ret;
    778         }
    779 
    780         Expression *EliminateTypedef::mutate( CastExpr * castExpr ) {
    781                 typedefNames.beginScope();
    782                 Expression *ret = Mutator::mutate( castExpr );
    783                 typedefNames.endScope();
    784                 return ret;
    785         }
    786 
    787         CompoundStmt *EliminateTypedef::mutate( CompoundStmt * compoundStmt ) {
    788                 typedefNames.beginScope();
     778                return objDecl;
     779        }
     780
     781        void EliminateTypedef::premutate( CastExpr * ) {
     782                GuardScope( typedefNames );
     783        }
     784
     785        void EliminateTypedef::premutate( CompoundStmt * ) {
     786                GuardScope( typedefNames );
    789787                scopeLevel += 1;
    790                 CompoundStmt *ret = Mutator::mutate( compoundStmt );
    791                 scopeLevel -= 1;
     788                GuardAction( [this](){ scopeLevel -= 1; } );
     789        }
     790
     791        CompoundStmt *EliminateTypedef::postmutate( CompoundStmt * compoundStmt ) {
    792792                // remove and delete decl stmts
    793793                filter( compoundStmt->kids, [](Statement * stmt) {
     
    799799                        return false;
    800800                }, true);
    801                 typedefNames.endScope();
    802                 return ret;
     801                return compoundStmt;
    803802        }
    804803
     
    827826        }
    828827
    829         Declaration *EliminateTypedef::mutate( StructDecl * structDecl ) {
     828        void EliminateTypedef::premutate( StructDecl * structDecl ) {
    830829                addImplicitTypedef( structDecl );
    831                 Mutator::mutate( structDecl );
     830        }
     831
     832
     833        Declaration *EliminateTypedef::postmutate( StructDecl * structDecl ) {
    832834                return handleAggregate( structDecl );
    833835        }
    834836
    835         Declaration *EliminateTypedef::mutate( UnionDecl * unionDecl ) {
     837        void EliminateTypedef::premutate( UnionDecl * unionDecl ) {
    836838                addImplicitTypedef( unionDecl );
    837                 Mutator::mutate( unionDecl );
     839        }
     840
     841        Declaration *EliminateTypedef::postmutate( UnionDecl * unionDecl ) {
    838842                return handleAggregate( unionDecl );
    839843        }
    840844
    841         Declaration *EliminateTypedef::mutate( EnumDecl * enumDecl ) {
     845        void EliminateTypedef::premutate( EnumDecl * enumDecl ) {
    842846                addImplicitTypedef( enumDecl );
    843                 Mutator::mutate( enumDecl );
     847        }
     848
     849        Declaration *EliminateTypedef::postmutate( EnumDecl * enumDecl ) {
    844850                return handleAggregate( enumDecl );
    845851        }
    846852
    847         Declaration *EliminateTypedef::mutate( TraitDecl * contextDecl ) {
    848                 Mutator::mutate( contextDecl );
    849                 return handleAggregate( contextDecl );
     853        Declaration *EliminateTypedef::postmutate( TraitDecl * traitDecl ) {
     854                return handleAggregate( traitDecl );
    850855        }
    851856
  • src/SynTree/BasicType.cc

    re3e16bc r982832e  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb  1 17:12:15 2017
    13 // Update Count     : 8
     12// Last Modified On : Mon Sep 11 12:52:05 2017
     13// Update Count     : 9
    1414//
    1515
     
    2525
    2626void BasicType::print( std::ostream &os, int indent ) const {
    27         static const char *kindNames[] = {     
    28                 "_Bool", "char", "signed char", "unsigned char", "short signed int", "short unsigned int",
    29                 "signed int", "unsigned int", "long signed int", "long unsigned int", "long long signed int",
    30                 "long long unsigned int", "float", "double", "long double", "float _Complex", "double _Complex",
    31                 "long double _Complex", "float _Imaginary", "double _Imaginary", "long double _Imaginary"
    32         };
    33 
    3427        Type::print( os, indent );
    35         os << kindNames[ kind ];
     28        os << BasicType::typeNames[ kind ];
    3629}
    3730
  • src/SynTree/Declaration.h

    re3e16bc r982832e  
    136136        Expression *get_bitfieldWidth() const { return bitfieldWidth; }
    137137        void set_bitfieldWidth( Expression *newValue ) { bitfieldWidth = newValue; }
     138
     139        static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init );
    138140
    139141        virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
     
    230232        virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
    231233        virtual void accept( Visitor &v ) { v.visit( this ); }
    232         virtual TypeDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     234        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    233235        virtual void print( std::ostream &os, int indent = 0 ) const;
    234236
  • src/SynTree/Mutator.cc

    re3e16bc r982832e  
    7878}
    7979
    80 TypeDecl * Mutator::mutate( TypeDecl *typeDecl ) {
     80Declaration * Mutator::mutate( TypeDecl *typeDecl ) {
    8181        handleNamedTypeDecl( typeDecl );
    8282        typeDecl->set_init( maybeMutate( typeDecl->get_init(), *this ) );
  • src/SynTree/Mutator.h

    re3e16bc r982832e  
    3131        virtual Declaration* mutate( EnumDecl *aggregateDecl );
    3232        virtual Declaration* mutate( TraitDecl *aggregateDecl );
    33         virtual TypeDecl* mutate( TypeDecl *typeDecl );
     33        virtual Declaration* mutate( TypeDecl *typeDecl );
    3434        virtual Declaration* mutate( TypedefDecl *typeDecl );
    3535        virtual AsmDecl* mutate( AsmDecl *asmDecl );
  • src/SynTree/ObjectDecl.cc

    re3e16bc r982832e  
    3838        delete init;
    3939        delete bitfieldWidth;
     40}
     41
     42ObjectDecl * ObjectDecl::newObject( const std::string & name, Type * type, Initializer * init ) {
     43        return new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
    4044}
    4145
  • src/SynTree/Statement.cc

    re3e16bc r982832e  
    472472}
    473473
    474 NullStmt::NullStmt( std::list<Label> labels ) : CompoundStmt( labels ) {}
    475 NullStmt::NullStmt() : CompoundStmt( std::list<Label>() ) {}
     474NullStmt::NullStmt( std::list<Label> labels ) : Statement( labels ) {}
     475NullStmt::NullStmt() : Statement( std::list<Label>() ) {}
    476476
    477477void NullStmt::print( std::ostream &os, __attribute__((unused)) int indent ) const {
  • src/SynTree/Statement.h

    re3e16bc r982832e  
    6767};
    6868
    69 class NullStmt : public CompoundStmt {
     69class NullStmt : public Statement {
    7070  public:
    7171        NullStmt();
  • src/SynTree/Type.cc

    re3e16bc r982832e  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Aug  2 11:11:00 2017
    13 // Update Count     : 29
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Sep 11 13:21:25 2017
     13// Update Count     : 37
    1414//
    1515#include "Type.h"
     
    2626        "_Bool",
    2727        "char",
    28         "char",
     28        "signed char",
    2929        "unsigned char",
    30         "short",
    31         "short unsigned",
    32         "int",
     30        "signed short int",
     31        "unsigned short int",
     32        "signed int",
    3333        "unsigned int",
    34         "long int",
    35         "long unsigned int",
    36         "long long int",
    37         "long long unsigned int",
     34        "signed long int",
     35        "unsigned long int",
     36        "signed long long int",
     37        "unsigned long long int",
    3838        "float",
    3939        "double",
     
    6565
    6666Type * Type::stripDeclarator() {
    67         Type * type = this;
    68         while ( Type * at = InitTweak::getPointerBase( type ) ) {
    69                 type = at;
    70         }
     67        Type * type, * at;
     68        for ( type = this; (at = InitTweak::getPointerBase( type )); type = at );
    7169        return type;
    7270}
    7371
    7472Type * Type::stripReferences() {
    75         Type * type = this;
    76         while ( ReferenceType * ref = dynamic_cast<ReferenceType *>( type ) ) {
    77                 type = ref->get_base();
    78         }
     73        Type * type;
     74        ReferenceType * ref;
     75        for ( type = this; (ref = dynamic_cast<ReferenceType *>( type )); type = ref->get_base() );
    7976        return type;
    8077}
  • src/libcfa/iostream

    re3e16bc r982832e  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 24 08:14:29 2017
    13 // Update Count     : 133
     12// Last Modified On : Mon Sep 11 09:17:07 2017
     13// Update Count     : 137
    1414//
    1515
    1616#pragma once
    1717
     18#include <uchar.h>
     19#include <wchar.h>
    1820#include "iterator"
    1921
     
    7880
    7981forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char * );
     82forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char16_t * );
     83forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char32_t * );
     84forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const wchar_t * );
    8085forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const void * );
    8186
     
    118123
    119124forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, char & );
     125forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, signed char & );
     126forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned char & );
    120127
    121128forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, short int & );
  • src/libcfa/iostream.c

    re3e16bc r982832e  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 24 08:41:53 2017
    13 // Update Count     : 405
     12// Last Modified On : Mon Sep 11 09:21:24 2017
     13// Update Count     : 420
    1414//
    1515
     
    145145
    146146forall( dtype ostype | ostream( ostype ) )
    147 ostype * ?|?( ostype * os, const char * cp ) {
     147ostype * ?|?( ostype * os, const char * str ) {
    148148        enum { Open = 1, Close, OpenClose };
    149149        static const unsigned char mask[256] @= {
     
    161161        }; // mask
    162162
    163   if ( cp[0] == '\0' ) { sepOff( os ); return os; }             // null string => no separator
     163  if ( str[0] == '\0' ) { sepOff( os ); return os; }            // null string => no separator
    164164
    165165        // first character IS NOT spacing or closing punctuation => add left separator
    166         unsigned char ch = cp[0];                                                       // must make unsigned
     166        unsigned char ch = str[0];                                                      // must make unsigned
    167167        if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
    168168                fmt( os, "%s", sepGetCur( os ) );
     
    173173
    174174        // last character IS spacing or opening punctuation => turn off separator for next item
    175         size_t len = strlen( cp );
    176         ch = cp[len - 1];                                                                       // must make unsigned
     175        size_t len = strlen( str );
     176        ch = str[len - 1];                                                                      // must make unsigned
    177177        if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
    178178                sepOn( os );
     
    181181        } // if
    182182        if ( ch == '\n' ) setNL( os, true );                            // check *AFTER* sepPrt call above as it resets NL flag
    183         return write( os, cp, len );
     183        return write( os, str, len );
     184} // ?|?
     185
     186forall( dtype ostype | ostream( ostype ) )
     187ostype * ?|?( ostype * os, const char16_t * str ) {
     188        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     189        fmt( os, "%ls", str );
     190        return os;
     191} // ?|?
     192
     193forall( dtype ostype | ostream( ostype ) )
     194ostype * ?|?( ostype * os, const char32_t * str ) {
     195        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     196        fmt( os, "%ls", str );
     197        return os;
     198} // ?|?
     199
     200forall( dtype ostype | ostream( ostype ) )
     201ostype * ?|?( ostype * os, const wchar_t * str ) {
     202        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     203        fmt( os, "%ls", str );
     204        return os;
    184205} // ?|?
    185206
     
    277298
    278299forall( dtype istype | istream( istype ) )
     300istype * ?|?( istype * is, signed char & sc ) {
     301        fmt( is, "%hhd", &sc );
     302        return is;
     303} // ?|?
     304
     305forall( dtype istype | istream( istype ) )
     306istype * ?|?( istype * is, unsigned char & usc ) {
     307        fmt( is, "%hhu", &usc );
     308        return is;
     309} // ?|?
     310
     311forall( dtype istype | istream( istype ) )
    279312istype * ?|?( istype * is, short int & si ) {
    280313        fmt( is, "%hd", &si );
  • src/tests/.expect/32/KRfunctions.txt

    re3e16bc r982832e  
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 int __f0__Fi_iPCii__1(int __a__i_1, const int *__b__PCi_1, int __c__i_1){
    8     __attribute__ ((unused)) int ___retval_f0__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7signed int __f0__Fi_iPCii__1(signed int __a__i_1, const signed int *__b__PCi_1, signed int __c__i_1){
     8    __attribute__ ((unused)) signed int ___retval_f0__i_1;
    99}
    10 int __f1__Fi_PiiPi__1(int *__a__Pi_1, __attribute__ ((unused)) int __b__i_1, int *__c__Pi_1){
    11     __attribute__ ((unused)) int ___retval_f1__i_1;
     10signed int __f1__Fi_PiiPi__1(signed int *__a__Pi_1, __attribute__ ((unused)) signed int __b__i_1, signed int *__c__Pi_1){
     11    __attribute__ ((unused)) signed int ___retval_f1__i_1;
    1212}
    13 int __f2__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    14     __attribute__ ((unused)) int ___retval_f2__i_1;
     13signed int __f2__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     14    __attribute__ ((unused)) signed int ___retval_f2__i_1;
    1515}
    1616struct S {
    17     int __i__i_1;
     17    signed int __i__i_1;
    1818};
    1919static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
     
    3636    return ((struct S )___ret__2sS_1);
    3737}
    38 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __i__i_1){
     38static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
    3939    ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
    4040}
    41 int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, int *__c__Pi_1){
    42     __attribute__ ((unused)) int ___retval_f3__i_1;
     41signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){
     42    __attribute__ ((unused)) signed int ___retval_f3__i_1;
    4343    struct S __s__2sS_2;
    4444}
    45 int __f4__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    46     __attribute__ ((unused)) int ___retval_f4__i_1;
     45signed int __f4__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     46    __attribute__ ((unused)) signed int ___retval_f4__i_1;
    4747}
    48 int __f5__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    49     __attribute__ ((unused)) int ___retval_f5__i_1;
     48signed int __f5__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     49    __attribute__ ((unused)) signed int ___retval_f5__i_1;
    5050}
    51 int (*__f6__FPFi_i__iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))(int __anonymous_object0){
    52     __attribute__ ((unused)) int (*___retval_f6__PFi_i__1)(int __anonymous_object1);
     51signed 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){
     52    __attribute__ ((unused)) signed int (*___retval_f6__PFi_i__1)(signed int __anonymous_object1);
    5353}
    54 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){
    55     __attribute__ ((unused)) int (*___retval_f7__PFi_ii__1)(int __a__i_1, int __b__i_1);
     54signed 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){
     55    __attribute__ ((unused)) signed int (*___retval_f7__PFi_ii__1)(signed int __a__i_1, signed int __b__i_1);
    5656}
    57 int *__f8__FPi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    58     __attribute__ ((unused)) int *___retval_f8__Pi_1;
     57signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     58    __attribute__ ((unused)) signed int *___retval_f8__Pi_1;
    5959}
    60 int *const __f9__FCPi_PiiPi__1(int *__a__Pi_1, int __b__i_1, int *__c__Pi_1){
    61     __attribute__ ((unused)) int *const ___retval_f9__CPi_1;
     60signed int *const __f9__FCPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
     61    __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1;
    6262}
    63 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){
    64     __attribute__ ((unused)) int *(*___retval_f10__PFPi_ii__1)(int __x__i_1, int __y__i_1);
    65     int *__x__FPi_ii__2(int __anonymous_object2, int __anonymous_object3);
     63signed 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){
     64    __attribute__ ((unused)) signed int *(*___retval_f10__PFPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
     65    signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
    6666    ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
    67     return ((int *(*)(int __x__i_1, int __y__i_1))___retval_f10__PFPi_ii__1);
     67    return ((signed int *(*)(signed int __x__i_1, signed int __y__i_1))___retval_f10__PFPi_ii__1);
    6868}
    69 int (*__f11__FPA0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[]{
    70     __attribute__ ((unused)) int (*___retval_f11__PA0i_1)[];
     69signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{
     70    __attribute__ ((unused)) signed int (*___retval_f11__PA0i_1)[];
    7171}
    72 int (*__f12__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((unsigned int )10)]{
    73     __attribute__ ((unused)) int (*___retval_f12__PA0A0i_1)[][((unsigned int )10)];
     72signed int (*__f12__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{
     73    __attribute__ ((unused)) signed int (*___retval_f12__PA0A0i_1)[][((unsigned int )10)];
    7474}
    75 int (*__f13__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((unsigned int )10)]{
    76     __attribute__ ((unused)) int (*___retval_f13__PA0A0i_1)[][((unsigned int )10)];
     75signed int (*__f13__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{
     76    __attribute__ ((unused)) signed int (*___retval_f13__PA0A0i_1)[][((unsigned int )10)];
    7777}
    78 int (*__f14__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((unsigned int )10)]{
    79     __attribute__ ((unused)) int (*___retval_f14__PA0A0i_1)[][((unsigned int )10)];
     78signed int (*__f14__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{
     79    __attribute__ ((unused)) signed int (*___retval_f14__PA0A0i_1)[][((unsigned int )10)];
    8080}
    81 int __f15__Fi_iii__1(int __a__i_1, int __b__i_1, int __c__i_1){
    82     __attribute__ ((unused)) int ___retval_f15__i_1;
     81signed int __f15__Fi_iii__1(signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
     82    __attribute__ ((unused)) signed int ___retval_f15__i_1;
    8383}
    84 const int __fred__FCi___1(){
    85     __attribute__ ((unused)) const int ___retval_fred__Ci_1;
    86     int *(*__x__PFPi_ii__2)(int __anonymous_object4, int __anonymous_object5);
    87     int __a__i_2;
    88     int __b__i_2;
    89     int *(*_tmp_cp_ret0)(int __x__i_1, int __y__i_1);
     84const signed int __fred__FCi___1(){
     85    __attribute__ ((unused)) const signed int ___retval_fred__Ci_1;
     86    signed int *(*__x__PFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
     87    signed int __a__i_2;
     88    signed int __b__i_2;
     89    signed int *(*_tmp_cp_ret0)(signed int __x__i_1, signed int __y__i_1);
    9090    ((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)));
    9191    ((void)(_tmp_cp_ret0) /* ^?{} */);
    92     const int __f1__FCi_iPiPi__2(int __a__i_2, int *__b__Pi_2, int *__c__Pi_2){
    93         __attribute__ ((unused)) const int ___retval_f1__Ci_2;
     92    const signed int __f1__FCi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
     93        __attribute__ ((unused)) const signed int ___retval_f1__Ci_2;
    9494    }
    95     const int __f2__FCi_iii__2(int __a__i_2, int __b__i_2, int __c__i_2){
    96         __attribute__ ((unused)) const int ___retval_f2__Ci_2;
     95    const signed int __f2__FCi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
     96        __attribute__ ((unused)) const signed int ___retval_f2__Ci_2;
    9797    }
    9898}
  • src/tests/.expect/32/attributes.txt

    re3e16bc r982832e  
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 int __la__Fi___1(){
    8     __attribute__ ((unused)) int ___retval_la__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7signed int __la__Fi___1(){
     8    __attribute__ ((unused)) signed int ___retval_la__i_1;
    99    L: __attribute__ ((unused)) ((void)1);
    1010}
     
    5454__attribute__ ((unused)) struct __anonymous3;
    5555struct Fdl {
    56     __attribute__ ((unused)) int __f1__i_1;
    57     __attribute__ ((unused)) int __f2__i_1;
    58     __attribute__ ((unused,unused)) int __f3__i_1;
    59     __attribute__ ((unused)) int __f4__i_1;
    60     __attribute__ ((unused,unused)) int __f5__i_1;
    61     __attribute__ ((used,packed)) int __f6__i_1;
    62     __attribute__ ((used,unused,unused)) int __f7__i_1;
    63     __attribute__ ((used,used,unused)) int __f8__i_1;
    64     __attribute__ ((unused)) int __anonymous_object0;
    65     __attribute__ ((unused,unused)) int *__f9__Pi_1;
     56    __attribute__ ((unused)) signed int __f1__i_1;
     57    __attribute__ ((unused)) signed int __f2__i_1;
     58    __attribute__ ((unused,unused)) signed int __f3__i_1;
     59    __attribute__ ((unused)) signed int __f4__i_1;
     60    __attribute__ ((unused,unused)) signed int __f5__i_1;
     61    __attribute__ ((used,packed)) signed int __f6__i_1;
     62    __attribute__ ((used,unused,unused)) signed int __f7__i_1;
     63    __attribute__ ((used,used,unused)) signed int __f8__i_1;
     64    __attribute__ ((unused)) signed int __anonymous_object0;
     65    __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
    6666};
    6767static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
     
    116116    return ((struct Fdl )___ret__4sFdl_1);
    117117}
    118 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1){
     118static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1){
    119119    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    120120    ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */);
     
    127127    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    128128}
    129 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1){
     129static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1){
    130130    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    131131    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    138138    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    139139}
    140 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){
     140static 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){
    141141    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    142142    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    149149    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    150150}
    151 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){
    152     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    153     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    154     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    155     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    156     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    157     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    158     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    159     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    160     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    161 }
    162 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){
    163     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    164     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    165     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    166     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    167     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    168     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    169     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    170     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    171     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    172 }
    173 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){
     151static 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){
     152    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     153    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     154    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     155    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     156    ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
     157    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
     158    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     159    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
     160    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
     161}
     162static 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){
     163    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     164    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     165    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     166    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     167    ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     168    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
     169    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     170    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
     171    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
     172}
     173static 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){
    174174    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    175175    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    182182    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    183183}
    184 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){
     184static 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){
    185185    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    186186    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    193193    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    194194}
    195 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){
     195static 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){
    196196    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    197197    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    204204    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    205205}
    206 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){
     206static 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){
    207207    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    208208    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    215215    ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
    216216}
    217 __attribute__ ((unused)) int __f__Fi___1() asm ( "xyz" );
    218 __attribute__ ((used,used)) const int __vd1__Ci_1;
    219 __attribute__ ((used,unused)) const int __vd2__Ci_1;
    220 __attribute__ ((used,used,used,used)) const int *__vd3__PCi_1;
    221 __attribute__ ((used,used,unused,used,unused)) const int *__vd4__PCi_1;
    222 __attribute__ ((used,used,used)) const int __vd5__A0Ci_1[((unsigned int )5)];
    223 __attribute__ ((used,used,unused,used)) const int __vd6__A0Ci_1[((unsigned int )5)];
    224 __attribute__ ((used,used,used,used)) const int (*__vd7__PFCi___1)();
    225 __attribute__ ((used,used,unused,used,used)) const int (*__vd8__PFCi___1)();
    226 __attribute__ ((unused,used)) int __f1__Fi___1();
    227 __attribute__ ((unused)) int __f1__Fi___1(){
    228     __attribute__ ((unused)) int ___retval_f1__i_1;
    229 }
    230 __attribute__ ((unused,unused,unused,used)) int **const __f2__FCPPi___1();
    231 __attribute__ ((unused,unused,unused)) int **const __f2__FCPPi___1(){
    232     __attribute__ ((unused)) int **const ___retval_f2__CPPi_1;
    233 }
    234 __attribute__ ((unused,used,unused)) int (*__f3__FPA0i_i__1(int __anonymous_object1))[];
    235 __attribute__ ((unused,unused)) int (*__f3__FPA0i_i__1(int __p__i_1))[]{
    236     __attribute__ ((unused)) int (*___retval_f3__PA0i_1)[];
    237 }
    238 __attribute__ ((unused,used,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object2);
    239 __attribute__ ((unused,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object3){
    240     __attribute__ ((unused)) int (*___retval_f4__PFi_i__1)(int __anonymous_object4);
    241 }
    242 int __vtr__Fi___1(){
    243     __attribute__ ((unused)) int ___retval_vtr__i_1;
    244     __attribute__ ((unused,unused,used)) int __t1__i_2;
    245     __attribute__ ((unused,unused,unused,unused,unused)) int **__t2__PPi_2;
    246     __attribute__ ((unused,unused,unused)) int __t3__A0i_2[((unsigned int )5)];
    247     __attribute__ ((unused,unused,unused,unused,unused)) int **__t4__A0PPi_2[((unsigned int )5)];
    248     __attribute__ ((unused,unused,unused)) int __t5__Fi___2();
    249     __attribute__ ((unused,unused,unused,unused)) int *__t6__FPi___2();
    250 }
    251 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1);
    252 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1){
    253     __attribute__ ((unused)) int ___retval_ipd1__i_1;
    254 }
    255 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
    256 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
    257     __attribute__ ((unused)) int ___retval_ipd2__i_1;
    258 }
    259 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
    260 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
    261     __attribute__ ((unused)) int ___retval_ipd3__i_1;
    262 }
    263 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)());
    264 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)()){
    265     __attribute__ ((unused)) int ___retval_ipd4__i_1;
    266 }
    267 int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) int __Foo__i_1);
    268 int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) int **__Foo__PPi_1);
    269 int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) int *__Foo__Pi_1);
    270 int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) int (*__anonymous_object5)(__attribute__ ((unused,unused)) int __anonymous_object6[((unsigned int )5)]));
    271 int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) int (*__Foo__PFi___1)());
    272 int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) int (*__Foo__PFi___1)());
    273 int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) int (*__anonymous_object7)(__attribute__ ((unused)) int (*__anonymous_object8)(__attribute__ ((unused,unused)) int __anonymous_object9)));
    274 int __ad__Fi___1(){
    275     __attribute__ ((unused)) int ___retval_ad__i_1;
    276     __attribute__ ((used,unused)) int __ad1__i_2;
    277     __attribute__ ((unused,unused,unused)) int *__ad2__Pi_2;
    278     __attribute__ ((unused,unused,unused)) int __ad3__A0i_2[((unsigned int )5)];
    279     __attribute__ ((unused,unused,unused,unused,unused)) int (*__ad4__PA0i_2)[((unsigned int )10)];
    280     __attribute__ ((unused,unused,unused,unused,used)) int __ad5__i_2;
    281     __attribute__ ((unused,unused,unused,unused,unused)) int __ad6__Fi___2();
    282     ((void)sizeof(__attribute__ ((unused,unused)) int ));
    283     ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) int **));
    284     ((void)sizeof(__attribute__ ((unused,unused,unused)) int [5]));
    285     ((void)sizeof(__attribute__ ((unused,unused,unused)) int (*)[10]));
    286     ((void)sizeof(__attribute__ ((unused,unused,unused)) int ()));
     217__attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
     218__attribute__ ((used,used)) const signed int __vd1__Ci_1;
     219__attribute__ ((used,unused)) const signed int __vd2__Ci_1;
     220__attribute__ ((used,used,used,used)) const signed int *__vd3__PCi_1;
     221__attribute__ ((used,used,unused,used,unused)) const signed int *__vd4__PCi_1;
     222__attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned int )5)];
     223__attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned int )5)];
     224__attribute__ ((used,used,used,used)) const signed int (*__vd7__PFCi___1)();
     225__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__PFCi___1)();
     226__attribute__ ((unused,used)) signed int __f1__Fi___1();
     227__attribute__ ((unused)) signed int __f1__Fi___1(){
     228    __attribute__ ((unused)) signed int ___retval_f1__i_1;
     229}
     230__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FCPPi___1();
     231__attribute__ ((unused,unused,unused)) signed int **const __f2__FCPPi___1(){
     232    __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
     233}
     234__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object1))[];
     235__attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
     236    __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
     237}
     238__attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object2);
     239__attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object3){
     240    __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object4);
     241}
     242signed int __vtr__Fi___1(){
     243    __attribute__ ((unused)) signed int ___retval_vtr__i_1;
     244    __attribute__ ((unused,unused,used)) signed int __t1__i_2;
     245    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t2__PPi_2;
     246    __attribute__ ((unused,unused,unused)) signed int __t3__A0i_2[((unsigned int )5)];
     247    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t4__A0PPi_2[((unsigned int )5)];
     248    __attribute__ ((unused,unused,unused)) signed int __t5__Fi___2();
     249    __attribute__ ((unused,unused,unused,unused)) signed int *__t6__FPi___2();
     250}
     251signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1);
     252signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1){
     253    __attribute__ ((unused)) signed int ___retval_ipd1__i_1;
     254}
     255signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     256signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     257    __attribute__ ((unused)) signed int ___retval_ipd2__i_1;
     258}
     259signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     260signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     261    __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
     262}
     263signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)());
     264signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)()){
     265    __attribute__ ((unused)) signed int ___retval_ipd4__i_1;
     266}
     267signed int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) signed int __Foo__i_1);
     268signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
     269signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
     270signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object5)(__attribute__ ((unused,unused)) signed int __anonymous_object6[((unsigned int )5)]));
     271signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
     272signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
     273signed 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)));
     274signed int __ad__Fi___1(){
     275    __attribute__ ((unused)) signed int ___retval_ad__i_1;
     276    __attribute__ ((used,unused)) signed int __ad1__i_2;
     277    __attribute__ ((unused,unused,unused)) signed int *__ad2__Pi_2;
     278    __attribute__ ((unused,unused,unused)) signed int __ad3__A0i_2[((unsigned int )5)];
     279    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*__ad4__PA0i_2)[((unsigned int )10)];
     280    __attribute__ ((unused,unused,unused,unused,used)) signed int __ad5__i_2;
     281    __attribute__ ((unused,unused,unused,unused,unused)) signed int __ad6__Fi___2();
     282    ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
     283    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
     284    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [5]));
     285    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[10]));
     286    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
    287287    __attribute__ ((unused)) struct __anonymous4 {
    288         int __i__i_2;
     288        signed int __i__i_2;
    289289    };
    290290    inline void ___constructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
     
    303303        return ((struct __anonymous4 )___ret__13s__anonymous4_2);
    304304    }
    305     inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, int __i__i_2){
     305    inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
    306306        ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
    307307    }
     
    324324    ((void)sizeof(enum __anonymous5 ));
    325325}
    326 int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object10, __attribute__ ((unused,unused,unused)) int *__anonymous_object11);
    327 int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) int **__anonymous_object13);
    328 int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object14, __attribute__ ((unused,unused,unused)) int *__anonymous_object15);
    329 int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) int (*__anonymous_object17)());
    330 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));
    331 int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) int (*__anonymous_object23)());
    332 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));
     326signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object10, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object11);
     327signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object13);
     328signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
     329signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)());
     330signed 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));
     331signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)());
     332signed 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));
    333333struct Vad {
    334     __attribute__ ((unused)) int __anonymous_object28;
    335     __attribute__ ((unused,unused)) int *__anonymous_object29;
    336     __attribute__ ((unused,unused)) int __anonymous_object30[((unsigned int )10)];
    337     __attribute__ ((unused,unused)) int (*__anonymous_object31)();
     334    __attribute__ ((unused)) signed int __anonymous_object28;
     335    __attribute__ ((unused,unused)) signed int *__anonymous_object29;
     336    __attribute__ ((unused,unused)) signed int __anonymous_object30[((unsigned int )10)];
     337    __attribute__ ((unused,unused)) signed int (*__anonymous_object31)();
    338338};
    339339static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
  • src/tests/.expect/32/declarationSpecifier.txt

    re3e16bc r982832e  
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 volatile const short __x1__CVs_1;
    8 static volatile const short __x2__CVs_1;
    9 static volatile const short __x3__CVs_1;
    10 static volatile const short __x4__CVs_1;
    11 static volatile const short __x5__CVs_1;
    12 static volatile const short __x6__CVs_1;
    13 static volatile const short __x7__CVs_1;
    14 static volatile const short __x8__CVs_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7volatile const signed short int __x1__CVs_1;
     8static volatile const signed short int __x2__CVs_1;
     9static volatile const signed short int __x3__CVs_1;
     10static volatile const signed short int __x4__CVs_1;
     11static volatile const signed short int __x5__CVs_1;
     12static volatile const signed short int __x6__CVs_1;
     13static volatile const signed short int __x7__CVs_1;
     14static volatile const signed short int __x8__CVs_1;
    1515struct __anonymous0 {
    16     int __i__i_1;
     16    signed int __i__i_1;
    1717};
    1818static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
     
    3535    return ((struct __anonymous0 )___ret__13s__anonymous0_1);
    3636}
    37 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, int __i__i_1){
     37static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){
    3838    ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
    3939}
    4040volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
    4141struct __anonymous1 {
    42     int __i__i_1;
     42    signed int __i__i_1;
    4343};
    4444static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
     
    6161    return ((struct __anonymous1 )___ret__13s__anonymous1_1);
    6262}
    63 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, int __i__i_1){
     63static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){
    6464    ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
    6565}
    6666volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
    6767struct __anonymous2 {
    68     int __i__i_1;
     68    signed int __i__i_1;
    6969};
    7070static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
     
    8787    return ((struct __anonymous2 )___ret__13s__anonymous2_1);
    8888}
    89 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, int __i__i_1){
     89static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){
    9090    ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
    9191}
    9292volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
    9393struct __anonymous3 {
    94     int __i__i_1;
     94    signed int __i__i_1;
    9595};
    9696static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
     
    113113    return ((struct __anonymous3 )___ret__13s__anonymous3_1);
    114114}
    115 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, int __i__i_1){
     115static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){
    116116    ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
    117117}
    118118static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
    119119struct __anonymous4 {
    120     int __i__i_1;
     120    signed int __i__i_1;
    121121};
    122122static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
     
    139139    return ((struct __anonymous4 )___ret__13s__anonymous4_1);
    140140}
    141 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, int __i__i_1){
     141static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){
    142142    ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
    143143}
    144144static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
    145145struct __anonymous5 {
    146     int __i__i_1;
     146    signed int __i__i_1;
    147147};
    148148static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
     
    165165    return ((struct __anonymous5 )___ret__13s__anonymous5_1);
    166166}
    167 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, int __i__i_1){
     167static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){
    168168    ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
    169169}
    170170static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
    171171struct __anonymous6 {
    172     int __i__i_1;
     172    signed int __i__i_1;
    173173};
    174174static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
     
    191191    return ((struct __anonymous6 )___ret__13s__anonymous6_1);
    192192}
    193 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, int __i__i_1){
     193static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){
    194194    ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
    195195}
    196196static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
    197197struct __anonymous7 {
    198     int __i__i_1;
     198    signed int __i__i_1;
    199199};
    200200static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
     
    217217    return ((struct __anonymous7 )___ret__13s__anonymous7_1);
    218218}
    219 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, int __i__i_1){
     219static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){
    220220    ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
    221221}
    222222static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
    223 volatile const short __x20__CVs_1;
    224 static volatile const short __x21__CVs_1;
    225 static volatile const short __x22__CVs_1;
    226 static volatile const short __x23__CVs_1;
    227 static volatile const short __x24__CVs_1;
    228 static volatile const short __x25__CVs_1;
    229 static volatile const short __x26__CVs_1;
    230 static volatile const short __x27__CVs_1;
     223volatile const signed short int __x20__CVs_1;
     224static volatile const signed short int __x21__CVs_1;
     225static volatile const signed short int __x22__CVs_1;
     226static volatile const signed short int __x23__CVs_1;
     227static volatile const signed short int __x24__CVs_1;
     228static volatile const signed short int __x25__CVs_1;
     229static volatile const signed short int __x26__CVs_1;
     230static volatile const signed short int __x27__CVs_1;
    231231struct __anonymous8 {
    232     short __i__s_1;
     232    signed short int __i__s_1;
    233233};
    234234static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
     
    251251    return ((struct __anonymous8 )___ret__13s__anonymous8_1);
    252252}
    253 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, short __i__s_1){
     253static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){
    254254    ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
    255255}
    256256volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
    257257struct __anonymous9 {
    258     short __i__s_1;
     258    signed short int __i__s_1;
    259259};
    260260static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
     
    277277    return ((struct __anonymous9 )___ret__13s__anonymous9_1);
    278278}
    279 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, short __i__s_1){
     279static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){
    280280    ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
    281281}
    282282volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
    283283struct __anonymous10 {
    284     short __i__s_1;
     284    signed short int __i__s_1;
    285285};
    286286static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
     
    303303    return ((struct __anonymous10 )___ret__14s__anonymous10_1);
    304304}
    305 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, short __i__s_1){
     305static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){
    306306    ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
    307307}
    308308volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
    309309struct __anonymous11 {
    310     short __i__s_1;
     310    signed short int __i__s_1;
    311311};
    312312static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
     
    329329    return ((struct __anonymous11 )___ret__14s__anonymous11_1);
    330330}
    331 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, short __i__s_1){
     331static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){
    332332    ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
    333333}
    334334static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
    335335struct __anonymous12 {
    336     short __i__s_1;
     336    signed short int __i__s_1;
    337337};
    338338static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
     
    355355    return ((struct __anonymous12 )___ret__14s__anonymous12_1);
    356356}
    357 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, short __i__s_1){
     357static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){
    358358    ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
    359359}
    360360static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
    361361struct __anonymous13 {
    362     short __i__s_1;
     362    signed short int __i__s_1;
    363363};
    364364static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
     
    381381    return ((struct __anonymous13 )___ret__14s__anonymous13_1);
    382382}
    383 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, short __i__s_1){
     383static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){
    384384    ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
    385385}
    386386static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
    387387struct __anonymous14 {
    388     short __i__s_1;
     388    signed short int __i__s_1;
    389389};
    390390static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
     
    407407    return ((struct __anonymous14 )___ret__14s__anonymous14_1);
    408408}
    409 static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, short __i__s_1){
     409static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1){
    410410    ((void)((*___dst__R14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
    411411}
    412412static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1;
    413413struct __anonymous15 {
    414     short __i__s_1;
     414    signed short int __i__s_1;
    415415};
    416416static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1);
     
    433433    return ((struct __anonymous15 )___ret__14s__anonymous15_1);
    434434}
    435 static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, short __i__s_1){
     435static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1){
    436436    ((void)((*___dst__R14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
    437437}
    438438static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1;
    439 static inline volatile const int __f11__FCVi___1();
    440 static inline volatile const int __f12__FCVi___1();
    441 static inline volatile const int __f13__FCVi___1();
    442 static inline volatile const int __f14__FCVi___1();
    443 static inline volatile const int __f15__FCVi___1();
    444 static inline volatile const int __f16__FCVi___1();
    445 static inline volatile const int __f17__FCVi___1();
    446 static inline volatile const int __f18__FCVi___1();
    447 static inline volatile const short __f21__FCVs___1();
    448 static inline volatile const short __f22__FCVs___1();
    449 static inline volatile const short __f23__FCVs___1();
    450 static inline volatile const short __f24__FCVs___1();
    451 static inline volatile const short __f25__FCVs___1();
    452 static inline volatile const short __f26__FCVs___1();
    453 static inline volatile const short __f27__FCVs___1();
    454 static inline volatile const short __f28__FCVs___1();
     439static inline volatile const signed int __f11__FCVi___1();
     440static inline volatile const signed int __f12__FCVi___1();
     441static inline volatile const signed int __f13__FCVi___1();
     442static inline volatile const signed int __f14__FCVi___1();
     443static inline volatile const signed int __f15__FCVi___1();
     444static inline volatile const signed int __f16__FCVi___1();
     445static inline volatile const signed int __f17__FCVi___1();
     446static inline volatile const signed int __f18__FCVi___1();
     447static inline volatile const signed short int __f21__FCVs___1();
     448static inline volatile const signed short int __f22__FCVs___1();
     449static inline volatile const signed short int __f23__FCVs___1();
     450static inline volatile const signed short int __f24__FCVs___1();
     451static inline volatile const signed short int __f25__FCVs___1();
     452static inline volatile const signed short int __f26__FCVs___1();
     453static inline volatile const signed short int __f27__FCVs___1();
     454static inline volatile const signed short int __f28__FCVs___1();
    455455struct __anonymous16 {
    456     int __i__i_1;
     456    signed int __i__i_1;
    457457};
    458458static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1);
     
    475475    return ((struct __anonymous16 )___ret__14s__anonymous16_1);
    476476}
    477 static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, int __i__i_1){
     477static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1){
    478478    ((void)((*___dst__R14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */);
    479479}
    480480static inline volatile const struct __anonymous16 __f31__FCV14s__anonymous16___1();
    481481struct __anonymous17 {
    482     int __i__i_1;
     482    signed int __i__i_1;
    483483};
    484484static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1);
     
    501501    return ((struct __anonymous17 )___ret__14s__anonymous17_1);
    502502}
    503 static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, int __i__i_1){
     503static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1){
    504504    ((void)((*___dst__R14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */);
    505505}
    506506static inline volatile const struct __anonymous17 __f32__FCV14s__anonymous17___1();
    507507struct __anonymous18 {
    508     int __i__i_1;
     508    signed int __i__i_1;
    509509};
    510510static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1);
     
    527527    return ((struct __anonymous18 )___ret__14s__anonymous18_1);
    528528}
    529 static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, int __i__i_1){
     529static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1){
    530530    ((void)((*___dst__R14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */);
    531531}
    532532static inline volatile const struct __anonymous18 __f33__FCV14s__anonymous18___1();
    533533struct __anonymous19 {
    534     int __i__i_1;
     534    signed int __i__i_1;
    535535};
    536536static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1);
     
    553553    return ((struct __anonymous19 )___ret__14s__anonymous19_1);
    554554}
    555 static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, int __i__i_1){
     555static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1){
    556556    ((void)((*___dst__R14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */);
    557557}
    558558static inline volatile const struct __anonymous19 __f34__FCV14s__anonymous19___1();
    559559struct __anonymous20 {
    560     int __i__i_1;
     560    signed int __i__i_1;
    561561};
    562562static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1);
     
    579579    return ((struct __anonymous20 )___ret__14s__anonymous20_1);
    580580}
    581 static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, int __i__i_1){
     581static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1){
    582582    ((void)((*___dst__R14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */);
    583583}
    584584static inline volatile const struct __anonymous20 __f35__FCV14s__anonymous20___1();
    585585struct __anonymous21 {
    586     int __i__i_1;
     586    signed int __i__i_1;
    587587};
    588588static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1);
     
    605605    return ((struct __anonymous21 )___ret__14s__anonymous21_1);
    606606}
    607 static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, int __i__i_1){
     607static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1){
    608608    ((void)((*___dst__R14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */);
    609609}
    610610static inline volatile const struct __anonymous21 __f36__FCV14s__anonymous21___1();
    611611struct __anonymous22 {
    612     int __i__i_1;
     612    signed int __i__i_1;
    613613};
    614614static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1);
     
    631631    return ((struct __anonymous22 )___ret__14s__anonymous22_1);
    632632}
    633 static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, int __i__i_1){
     633static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1){
    634634    ((void)((*___dst__R14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */);
    635635}
    636636static inline volatile const struct __anonymous22 __f37__FCV14s__anonymous22___1();
    637637struct __anonymous23 {
    638     int __i__i_1;
     638    signed int __i__i_1;
    639639};
    640640static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1);
     
    657657    return ((struct __anonymous23 )___ret__14s__anonymous23_1);
    658658}
    659 static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, int __i__i_1){
     659static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1){
    660660    ((void)((*___dst__R14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */);
    661661}
    662662static inline volatile const struct __anonymous23 __f38__FCV14s__anonymous23___1();
    663 static inline volatile const short __f41__FCVs___1();
    664 static inline volatile const short __f42__FCVs___1();
    665 static inline volatile const short __f43__FCVs___1();
    666 static inline volatile const short __f44__FCVs___1();
    667 static inline volatile const short __f45__FCVs___1();
    668 static inline volatile const short __f46__FCVs___1();
    669 static inline volatile const short __f47__FCVs___1();
    670 static inline volatile const short __f48__FCVs___1();
    671 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
    672     __attribute__ ((unused)) int ___retval_main__i_1;
    673     ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
    674     return ((int )___retval_main__i_1);
     663static inline volatile const signed short int __f41__FCVs___1();
     664static inline volatile const signed short int __f42__FCVs___1();
     665static inline volatile const signed short int __f43__FCVs___1();
     666static inline volatile const signed short int __f44__FCVs___1();
     667static inline volatile const signed short int __f45__FCVs___1();
     668static inline volatile const signed short int __f46__FCVs___1();
     669static inline volatile const signed short int __f47__FCVs___1();
     670static inline volatile const signed short int __f48__FCVs___1();
     671signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     672    __attribute__ ((unused)) signed int ___retval_main__i_1;
     673    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     674    return ((signed int )___retval_main__i_1);
    675675    ((void)(___retval_main__i_1=0) /* ?{} */);
    676     return ((int )___retval_main__i_1);
     676    return ((signed int )___retval_main__i_1);
    677677}
    678678static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
     
    680680__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    681681__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    682 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    683 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    684 extern int printf(const char *__restrict __format, ...);
    685 static inline int invoke_main(int argc, char **argv, char **envp);
    686 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
    687     __attribute__ ((unused)) int ___retval_main__i_1;
    688     int _tmp_cp_ret0;
     682__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     683__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     684extern signed int printf(const char *__restrict __format, ...);
     685static inline signed int invoke_main(signed int argc, char **argv, char **envp);
     686signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     687    __attribute__ ((unused)) signed int ___retval_main__i_1;
     688    signed int _tmp_cp_ret0;
    689689    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
    690690    ((void)(_tmp_cp_ret0) /* ^?{} */);
    691     return ((int )___retval_main__i_1);
    692 }
     691    return ((signed int )___retval_main__i_1);
     692}
  • src/tests/.expect/32/extension.txt

    re3e16bc r982832e  
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 __extension__ int __a__i_1;
    8 __extension__ int __b__i_1;
    9 __extension__ int __c__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7__extension__ signed int __a__i_1;
     8__extension__ signed int __b__i_1;
     9__extension__ signed int __c__i_1;
    1010__extension__ struct S {
    11     __extension__ int __a__i_1;
    12     __extension__ int __b__i_1;
    13     __extension__ int __c__i_1;
     11    __extension__ signed int __a__i_1;
     12    __extension__ signed int __b__i_1;
     13    __extension__ signed int __c__i_1;
    1414};
    1515static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
     
    4040    return ((struct S )___ret__2sS_1);
    4141}
    42 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __a__i_1){
     42static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
    4343    ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
    4444    ((void)((*___dst__R2sS_1).__b__i_1) /* ?{} */);
    4545    ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
    4646}
    47 static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1){
     47static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1){
    4848    ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
    4949    ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
    5050    ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
    5151}
    52 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){
     52static 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){
    5353    ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
    5454    ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     
    5656}
    5757__extension__ union U {
    58     __extension__ int __a__i_1;
    59     __extension__ int __b__i_1;
    60     __extension__ int __c__i_1;
     58    __extension__ signed int __a__i_1;
     59    __extension__ signed int __b__i_1;
     60    __extension__ signed int __c__i_1;
    6161};
    6262static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
     
    7373    return ((union U )___ret__2uU_1);
    7474}
    75 static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, int __src__i_1){
    76     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(int )));
     75static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, signed int __src__i_1){
     76    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(signed int )));
    7777}
    7878__extension__ enum E {
     
    8181    __B__C2eE_1,
    8282};
    83 __extension__ int __f__Fi___1();
    84 __extension__ int i;
    85 __extension__ int j;
    86 __extension__ int __fred__Fi_i__1(int __p__i_1){
    87     __attribute__ ((unused)) int ___retval_fred__i_1;
     83__extension__ signed int __f__Fi___1();
     84__extension__ signed int i;
     85__extension__ signed int j;
     86__extension__ signed int __fred__Fi_i__1(signed int __p__i_1){
     87    __attribute__ ((unused)) signed int ___retval_fred__i_1;
    8888    __extension__ struct S {
    89         __extension__ int __a__i_2;
    90         __extension__ int __b__i_2;
    91         __extension__ int __c__i_2;
    92         __extension__ int *__x__Pi_2;
    93         __extension__ int *__y__Pi_2;
    94         __extension__ int *__z__Pi_2;
     89        __extension__ signed int __a__i_2;
     90        __extension__ signed int __b__i_2;
     91        __extension__ signed int __c__i_2;
     92        __extension__ signed int *__x__Pi_2;
     93        __extension__ signed int *__y__Pi_2;
     94        __extension__ signed int *__z__Pi_2;
    9595    };
    96     int __i__i_2 = ((int )(__extension__ __a__i_1+__extension__ 3));
     96    signed int __i__i_2 = ((signed int )(__extension__ __a__i_1+__extension__ 3));
    9797    ((void)__extension__ 3);
    9898    ((void)__extension__ __a__i_1);
    99     __extension__ int __a__i_2;
    100     __extension__ int __b__i_2;
    101     __extension__ int __c__i_2;
     99    __extension__ signed int __a__i_2;
     100    __extension__ signed int __b__i_2;
     101    __extension__ signed int __c__i_2;
    102102    ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
    103     int _tmp_cp_ret0;
     103    signed int _tmp_cp_ret0;
    104104    ((void)(((void)(_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3))) , _tmp_cp_ret0));
    105105    ((void)(_tmp_cp_ret0) /* ^?{} */);
    106     __extension__ int __mary__Fi_i__2(int __p__i_2){
    107         __attribute__ ((unused)) int ___retval_mary__i_2;
     106    __extension__ signed int __mary__Fi_i__2(signed int __p__i_2){
     107        __attribute__ ((unused)) signed int ___retval_mary__i_2;
    108108    }
    109109    ((void)__extension__ sizeof(3));
    110     ((void)__extension__ (((int )(3!=((int )0))) || ((int )(4!=((int )0)))));
     110    ((void)__extension__ (((signed int )(3!=((signed int )0))) || ((signed int )(4!=((signed int )0)))));
    111111    ((void)__extension__ __alignof__(__extension__ __a__i_2));
    112     ((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)))));
    113     ((void)(((int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
     112    ((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)))));
     113    ((void)(((signed int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
    114114    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
    115115    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
  • src/tests/.expect/32/gccExtensions.txt

    re3e16bc r982832e  
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 extern int __x__i_1 asm ( "xx" );
    8 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
    9     __attribute__ ((unused)) int ___retval_main__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7extern signed int __x__i_1 asm ( "xx" );
     8signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     9    __attribute__ ((unused)) signed int ___retval_main__i_1;
    1010    asm ( "nop" :  :  :  );
    1111    asm ( "nop" :  :  :  );
    1212    asm ( "nop" :  :  :  );
    13     static int __y__i_2 asm ( "yy" );
    14     static int *__z__Pi_2 asm ( "zz" );
    15     int __src__i_2;
    16     int __dst__i_2;
    17     asm volatile ( "mov %1, %0\n\tadd $1, %0" :  :  :  );
    18     asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) :  :  );
    19     asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
    20     asm ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
     13    static signed int __y__i_2 asm ( "yy" );
     14    static signed int *__z__Pi_2 asm ( "zz" );
     15    signed int __src__i_2;
     16    signed int __dst__i_2;
     17    asm volatile ( "mov %1, %0\n\t" "add $1, %0" :  :  :  );
     18    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( __dst__i_2 ) :  :  );
     19    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
     20    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" );
    2121    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 );
    2222    double _Complex __c1__Xd_2;
    2323    double _Complex __c2__Xd_2;
    24     const int __i1__Ci_2;
    25     const int __i2__Ci_2;
    26     const int __i3__Ci_2;
    27     inline int __f1__Fi___2(){
    28         __attribute__ ((unused)) int ___retval_f1__i_2;
     24    const signed int __i1__Ci_2;
     25    const signed int __i2__Ci_2;
     26    const signed int __i3__Ci_2;
     27    inline signed int __f1__Fi___2(){
     28        __attribute__ ((unused)) signed int ___retval_f1__i_2;
    2929    }
    30     inline int __f2__Fi___2(){
    31         __attribute__ ((unused)) int ___retval_f2__i_2;
     30    inline signed int __f2__Fi___2(){
     31        __attribute__ ((unused)) signed int ___retval_f2__i_2;
    3232    }
    33     int __s1__i_2;
    34     int __s2__i_2;
    35     volatile int __v1__Vi_2;
    36     volatile int __v2__Vi_2;
    37     int __t1___2;
    38     int __t2___2;
    39     __extension__ const int __ex__Ci_2;
     33    signed int __s1__i_2;
     34    signed int __s2__i_2;
     35    volatile signed int __v1__Vi_2;
     36    volatile signed int __v2__Vi_2;
     37    signed int __t1___2;
     38    signed int __t2___2;
     39    __extension__ const signed int __ex__Ci_2;
    4040    struct S {
    41         __extension__ int __a__i_2;
    42         __extension__ int __b__i_2;
    43         __extension__ int __c__i_2;
     41        __extension__ signed int __a__i_2;
     42        __extension__ signed int __b__i_2;
     43        __extension__ signed int __c__i_2;
    4444    };
    4545    inline void ___constructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
     
    6666        return ((struct S )___ret__2sS_2);
    6767    }
    68     inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, int __a__i_2){
     68    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
    6969        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
    7070        ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
    7171        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
    7272    }
    73     inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2){
     73    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2){
    7474        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
    7575        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
    7676        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
    7777    }
    78     inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2, int __c__i_2){
     78    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){
    7979        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
    8080        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
    8181        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
    8282    }
    83     int __i__i_2 = ((int )__extension__ 3);
    84     __extension__ int __a__i_2;
    85     __extension__ int __b__i_2;
    86     __extension__ int __c__i_2;
     83    signed int __i__i_2 = ((signed int )__extension__ 3);
     84    __extension__ signed int __a__i_2;
     85    __extension__ signed int __b__i_2;
     86    __extension__ signed int __c__i_2;
    8787    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
    8888    ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
    8989    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
    90     int __a1__i_2;
    91     const int __a2__Ci_2;
    92     static const int __a3__Ci_2;
    93     static const int __a4__Ci_2;
    94     static const int __a5__Ci_2;
    95     static const int __a6__Ci_2;
    96     static const int __a7__Ci_2;
    97     int *__p1__Pi_2;
    98     int *__p2__Pi_2;
     90    signed int __a1__i_2;
     91    const signed int __a2__Ci_2;
     92    static const signed int __a3__Ci_2;
     93    static const signed int __a4__Ci_2;
     94    static const signed int __a5__Ci_2;
     95    static const signed int __a6__Ci_2;
     96    static const signed int __a7__Ci_2;
     97    signed int *__p1__Pi_2;
     98    signed int *__p2__Pi_2;
    9999    struct s1;
    100100    struct s2 {
    101         int __i__i_2;
     101        signed int __i__i_2;
    102102    };
    103103    inline void ___constructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){
     
    116116        return ((struct s2 )___ret__3ss2_2);
    117117    }
    118     inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, int __i__i_2){
     118    inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
    119119        ((void)((*___dst__R3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
    120120    }
    121121    struct s3 {
    122         int __i__i_2;
     122        signed int __i__i_2;
    123123    };
    124124    inline void ___constructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){
     
    137137        return ((struct s3 )___ret__3ss3_2);
    138138    }
    139     inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, int __i__i_2){
     139    inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
    140140        ((void)((*___dst__R3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
    141141    }
     
    143143    struct s3 __y1__3ss3_2;
    144144    struct s4 {
    145         int __i__i_2;
     145        signed int __i__i_2;
    146146    };
    147147    inline void ___constructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){
     
    160160        return ((struct s4 )___ret__3ss4_2);
    161161    }
    162     inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, int __i__i_2){
     162    inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
    163163        ((void)((*___dst__R3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
    164164    }
    165165    struct s4 __x2__3ss4_2;
    166166    struct s4 __y2__3ss4_2;
    167     int __m1__A0i_2[((unsigned int )10)];
    168     int __m2__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
    169     int __m3__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
    170     ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
    171     return ((int )___retval_main__i_1);
     167    signed int __m1__A0i_2[((unsigned int )10)];
     168    signed int __m2__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
     169    signed int __m3__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
     170    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     171    return ((signed int )___retval_main__i_1);
    172172    ((void)(___retval_main__i_1=0) /* ?{} */);
    173     return ((int )___retval_main__i_1);
     173    return ((signed int )___retval_main__i_1);
    174174}
    175175static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
     
    177177__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    178178__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    179 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    180 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    181 extern int printf(const char *__restrict __format, ...);
    182 static inline int invoke_main(int argc, char **argv, char **envp);
    183 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
    184     __attribute__ ((unused)) int ___retval_main__i_1;
    185     int _tmp_cp_ret0;
     179__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     180__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     181extern signed int printf(const char *__restrict __format, ...);
     182static inline signed int invoke_main(signed int argc, char **argv, char **envp);
     183signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     184    __attribute__ ((unused)) signed int ___retval_main__i_1;
     185    signed int _tmp_cp_ret0;
    186186    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
    187187    ((void)(_tmp_cp_ret0) /* ^?{} */);
    188     return ((int )___retval_main__i_1);
     188    return ((signed int )___retval_main__i_1);
    189189}
  • src/tests/.expect/64/KRfunctions.txt

    re3e16bc r982832e  
    1 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     1__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 int __f0__Fi_iPCii__1(int __a__i_1, const int *__b__PCi_1, int __c__i_1){
    8     __attribute__ ((unused)) int ___retval_f0__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7signed int __f0__Fi_iPCii__1(signed int __a__i_1, const signed int *__b__PCi_1, signed int __c__i_1){
     8    __attribute__ ((unused)) signed int ___retval_f0__i_1;
    99}
    10 int __f1__Fi_PiiPi__1(int *__a__Pi_1, __attribute__ ((unused)) int __b__i_1, int *__c__Pi_1){
    11     __attribute__ ((unused)) int ___retval_f1__i_1;
     10signed int __f1__Fi_PiiPi__1(signed int *__a__Pi_1, __attribute__ ((unused)) signed int __b__i_1, signed int *__c__Pi_1){
     11    __attribute__ ((unused)) signed int ___retval_f1__i_1;
    1212}
    13 int __f2__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    14     __attribute__ ((unused)) int ___retval_f2__i_1;
     13signed int __f2__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     14    __attribute__ ((unused)) signed int ___retval_f2__i_1;
    1515}
    1616struct S {
    17     int __i__i_1;
     17    signed int __i__i_1;
    1818};
    1919static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
     
    3636    return ((struct S )___ret__2sS_1);
    3737}
    38 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __i__i_1){
     38static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
    3939    ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
    4040}
    41 int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, int *__c__Pi_1){
    42     __attribute__ ((unused)) int ___retval_f3__i_1;
     41signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){
     42    __attribute__ ((unused)) signed int ___retval_f3__i_1;
    4343    struct S __s__2sS_2;
    4444}
    45 int __f4__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    46     __attribute__ ((unused)) int ___retval_f4__i_1;
     45signed int __f4__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     46    __attribute__ ((unused)) signed int ___retval_f4__i_1;
    4747}
    48 int __f5__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    49     __attribute__ ((unused)) int ___retval_f5__i_1;
     48signed int __f5__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     49    __attribute__ ((unused)) signed int ___retval_f5__i_1;
    5050}
    51 int (*__f6__FPFi_i__iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))(int __anonymous_object0){
    52     __attribute__ ((unused)) int (*___retval_f6__PFi_i__1)(int __anonymous_object1);
     51signed 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){
     52    __attribute__ ((unused)) signed int (*___retval_f6__PFi_i__1)(signed int __anonymous_object1);
    5353}
    54 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){
    55     __attribute__ ((unused)) int (*___retval_f7__PFi_ii__1)(int __a__i_1, int __b__i_1);
     54signed 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){
     55    __attribute__ ((unused)) signed int (*___retval_f7__PFi_ii__1)(signed int __a__i_1, signed int __b__i_1);
    5656}
    57 int *__f8__FPi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    58     __attribute__ ((unused)) int *___retval_f8__Pi_1;
     57signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     58    __attribute__ ((unused)) signed int *___retval_f8__Pi_1;
    5959}
    60 int *const __f9__FCPi_PiiPi__1(int *__a__Pi_1, int __b__i_1, int *__c__Pi_1){
    61     __attribute__ ((unused)) int *const ___retval_f9__CPi_1;
     60signed int *const __f9__FCPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
     61    __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1;
    6262}
    63 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){
    64     __attribute__ ((unused)) int *(*___retval_f10__PFPi_ii__1)(int __x__i_1, int __y__i_1);
    65     int *__x__FPi_ii__2(int __anonymous_object2, int __anonymous_object3);
     63signed 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){
     64    __attribute__ ((unused)) signed int *(*___retval_f10__PFPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
     65    signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
    6666    ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
    67     return ((int *(*)(int __x__i_1, int __y__i_1))___retval_f10__PFPi_ii__1);
     67    return ((signed int *(*)(signed int __x__i_1, signed int __y__i_1))___retval_f10__PFPi_ii__1);
    6868}
    69 int (*__f11__FPA0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[]{
    70     __attribute__ ((unused)) int (*___retval_f11__PA0i_1)[];
     69signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{
     70    __attribute__ ((unused)) signed int (*___retval_f11__PA0i_1)[];
    7171}
    72 int (*__f12__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
    73     __attribute__ ((unused)) int (*___retval_f12__PA0A0i_1)[][((long unsigned int )10)];
     72signed int (*__f12__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
     73    __attribute__ ((unused)) signed int (*___retval_f12__PA0A0i_1)[][((unsigned long int )10)];
    7474}
    75 int (*__f13__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
    76     __attribute__ ((unused)) int (*___retval_f13__PA0A0i_1)[][((long unsigned int )10)];
     75signed int (*__f13__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
     76    __attribute__ ((unused)) signed int (*___retval_f13__PA0A0i_1)[][((unsigned long int )10)];
    7777}
    78 int (*__f14__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
    79     __attribute__ ((unused)) int (*___retval_f14__PA0A0i_1)[][((long unsigned int )10)];
     78signed int (*__f14__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
     79    __attribute__ ((unused)) signed int (*___retval_f14__PA0A0i_1)[][((unsigned long int )10)];
    8080}
    81 int __f15__Fi_iii__1(int __a__i_1, int __b__i_1, int __c__i_1){
    82     __attribute__ ((unused)) int ___retval_f15__i_1;
     81signed int __f15__Fi_iii__1(signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
     82    __attribute__ ((unused)) signed int ___retval_f15__i_1;
    8383}
    84 const int __fred__FCi___1(){
    85     __attribute__ ((unused)) const int ___retval_fred__Ci_1;
    86     int *(*__x__PFPi_ii__2)(int __anonymous_object4, int __anonymous_object5);
    87     int __a__i_2;
    88     int __b__i_2;
    89     int *(*_tmp_cp_ret0)(int __x__i_1, int __y__i_1);
     84const signed int __fred__FCi___1(){
     85    __attribute__ ((unused)) const signed int ___retval_fred__Ci_1;
     86    signed int *(*__x__PFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
     87    signed int __a__i_2;
     88    signed int __b__i_2;
     89    signed int *(*_tmp_cp_ret0)(signed int __x__i_1, signed int __y__i_1);
    9090    ((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)));
    9191    ((void)(_tmp_cp_ret0) /* ^?{} */);
    92     const int __f1__FCi_iPiPi__2(int __a__i_2, int *__b__Pi_2, int *__c__Pi_2){
    93         __attribute__ ((unused)) const int ___retval_f1__Ci_2;
     92    const signed int __f1__FCi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
     93        __attribute__ ((unused)) const signed int ___retval_f1__Ci_2;
    9494    }
    95     const int __f2__FCi_iii__2(int __a__i_2, int __b__i_2, int __c__i_2){
    96         __attribute__ ((unused)) const int ___retval_f2__Ci_2;
     95    const signed int __f2__FCi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
     96        __attribute__ ((unused)) const signed int ___retval_f2__Ci_2;
    9797    }
    9898}
  • src/tests/.expect/64/attributes.txt

    re3e16bc r982832e  
    1 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     1__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 int __la__Fi___1(){
    8     __attribute__ ((unused)) int ___retval_la__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7signed int __la__Fi___1(){
     8    __attribute__ ((unused)) signed int ___retval_la__i_1;
    99    L: __attribute__ ((unused)) ((void)1);
    1010}
     
    5454__attribute__ ((unused)) struct __anonymous3;
    5555struct Fdl {
    56     __attribute__ ((unused)) int __f1__i_1;
    57     __attribute__ ((unused)) int __f2__i_1;
    58     __attribute__ ((unused,unused)) int __f3__i_1;
    59     __attribute__ ((unused)) int __f4__i_1;
    60     __attribute__ ((unused,unused)) int __f5__i_1;
    61     __attribute__ ((used,packed)) int __f6__i_1;
    62     __attribute__ ((used,unused,unused)) int __f7__i_1;
    63     __attribute__ ((used,used,unused)) int __f8__i_1;
    64     __attribute__ ((unused)) int __anonymous_object0;
    65     __attribute__ ((unused,unused)) int *__f9__Pi_1;
     56    __attribute__ ((unused)) signed int __f1__i_1;
     57    __attribute__ ((unused)) signed int __f2__i_1;
     58    __attribute__ ((unused,unused)) signed int __f3__i_1;
     59    __attribute__ ((unused)) signed int __f4__i_1;
     60    __attribute__ ((unused,unused)) signed int __f5__i_1;
     61    __attribute__ ((used,packed)) signed int __f6__i_1;
     62    __attribute__ ((used,unused,unused)) signed int __f7__i_1;
     63    __attribute__ ((used,used,unused)) signed int __f8__i_1;
     64    __attribute__ ((unused)) signed int __anonymous_object0;
     65    __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
    6666};
    6767static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
     
    116116    return ((struct Fdl )___ret__4sFdl_1);
    117117}
    118 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1){
     118static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1){
    119119    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    120120    ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */);
     
    127127    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    128128}
    129 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1){
     129static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1){
    130130    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    131131    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    138138    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    139139}
    140 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){
     140static 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){
    141141    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    142142    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    149149    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    150150}
    151 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){
    152     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    153     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    154     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    155     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    156     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    157     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    158     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    159     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    160     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    161 }
    162 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){
    163     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    164     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    165     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    166     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    167     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    168     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    169     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    170     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    171     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    172 }
    173 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){
     151static 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){
     152    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     153    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     154    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     155    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     156    ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
     157    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
     158    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     159    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
     160    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
     161}
     162static 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){
     163    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     164    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     165    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     166    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     167    ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     168    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
     169    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     170    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
     171    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
     172}
     173static 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){
    174174    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    175175    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    182182    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    183183}
    184 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){
     184static 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){
    185185    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    186186    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    193193    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    194194}
    195 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){
     195static 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){
    196196    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    197197    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    204204    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    205205}
    206 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){
     206static 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){
    207207    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    208208    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    215215    ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
    216216}
    217 __attribute__ ((unused)) int __f__Fi___1() asm ( "xyz" );
    218 __attribute__ ((used,used)) const int __vd1__Ci_1;
    219 __attribute__ ((used,unused)) const int __vd2__Ci_1;
    220 __attribute__ ((used,used,used,used)) const int *__vd3__PCi_1;
    221 __attribute__ ((used,used,unused,used,unused)) const int *__vd4__PCi_1;
    222 __attribute__ ((used,used,used)) const int __vd5__A0Ci_1[((long unsigned int )5)];
    223 __attribute__ ((used,used,unused,used)) const int __vd6__A0Ci_1[((long unsigned int )5)];
    224 __attribute__ ((used,used,used,used)) const int (*__vd7__PFCi___1)();
    225 __attribute__ ((used,used,unused,used,used)) const int (*__vd8__PFCi___1)();
    226 __attribute__ ((unused,used)) int __f1__Fi___1();
    227 __attribute__ ((unused)) int __f1__Fi___1(){
    228     __attribute__ ((unused)) int ___retval_f1__i_1;
    229 }
    230 __attribute__ ((unused,unused,unused,used)) int **const __f2__FCPPi___1();
    231 __attribute__ ((unused,unused,unused)) int **const __f2__FCPPi___1(){
    232     __attribute__ ((unused)) int **const ___retval_f2__CPPi_1;
    233 }
    234 __attribute__ ((unused,used,unused)) int (*__f3__FPA0i_i__1(int __anonymous_object1))[];
    235 __attribute__ ((unused,unused)) int (*__f3__FPA0i_i__1(int __p__i_1))[]{
    236     __attribute__ ((unused)) int (*___retval_f3__PA0i_1)[];
    237 }
    238 __attribute__ ((unused,used,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object2);
    239 __attribute__ ((unused,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object3){
    240     __attribute__ ((unused)) int (*___retval_f4__PFi_i__1)(int __anonymous_object4);
    241 }
    242 int __vtr__Fi___1(){
    243     __attribute__ ((unused)) int ___retval_vtr__i_1;
    244     __attribute__ ((unused,unused,used)) int __t1__i_2;
    245     __attribute__ ((unused,unused,unused,unused,unused)) int **__t2__PPi_2;
    246     __attribute__ ((unused,unused,unused)) int __t3__A0i_2[((long unsigned int )5)];
    247     __attribute__ ((unused,unused,unused,unused,unused)) int **__t4__A0PPi_2[((long unsigned int )5)];
    248     __attribute__ ((unused,unused,unused)) int __t5__Fi___2();
    249     __attribute__ ((unused,unused,unused,unused)) int *__t6__FPi___2();
    250 }
    251 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1);
    252 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1){
    253     __attribute__ ((unused)) int ___retval_ipd1__i_1;
    254 }
    255 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
    256 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
    257     __attribute__ ((unused)) int ___retval_ipd2__i_1;
    258 }
    259 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
    260 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
    261     __attribute__ ((unused)) int ___retval_ipd3__i_1;
    262 }
    263 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)());
    264 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)()){
    265     __attribute__ ((unused)) int ___retval_ipd4__i_1;
    266 }
    267 int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) int __Foo__i_1);
    268 int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) int **__Foo__PPi_1);
    269 int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) int *__Foo__Pi_1);
    270 int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) int (*__anonymous_object5)(__attribute__ ((unused,unused)) int __anonymous_object6[((long unsigned int )5)]));
    271 int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) int (*__Foo__PFi___1)());
    272 int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) int (*__Foo__PFi___1)());
    273 int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) int (*__anonymous_object7)(__attribute__ ((unused)) int (*__anonymous_object8)(__attribute__ ((unused,unused)) int __anonymous_object9)));
    274 int __ad__Fi___1(){
    275     __attribute__ ((unused)) int ___retval_ad__i_1;
    276     __attribute__ ((used,unused)) int __ad1__i_2;
    277     __attribute__ ((unused,unused,unused)) int *__ad2__Pi_2;
    278     __attribute__ ((unused,unused,unused)) int __ad3__A0i_2[((long unsigned int )5)];
    279     __attribute__ ((unused,unused,unused,unused,unused)) int (*__ad4__PA0i_2)[((long unsigned int )10)];
    280     __attribute__ ((unused,unused,unused,unused,used)) int __ad5__i_2;
    281     __attribute__ ((unused,unused,unused,unused,unused)) int __ad6__Fi___2();
    282     ((void)sizeof(__attribute__ ((unused,unused)) int ));
    283     ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) int **));
    284     ((void)sizeof(__attribute__ ((unused,unused,unused)) int [5]));
    285     ((void)sizeof(__attribute__ ((unused,unused,unused)) int (*)[10]));
    286     ((void)sizeof(__attribute__ ((unused,unused,unused)) int ()));
     217__attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
     218__attribute__ ((used,used)) const signed int __vd1__Ci_1;
     219__attribute__ ((used,unused)) const signed int __vd2__Ci_1;
     220__attribute__ ((used,used,used,used)) const signed int *__vd3__PCi_1;
     221__attribute__ ((used,used,unused,used,unused)) const signed int *__vd4__PCi_1;
     222__attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned long int )5)];
     223__attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned long int )5)];
     224__attribute__ ((used,used,used,used)) const signed int (*__vd7__PFCi___1)();
     225__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__PFCi___1)();
     226__attribute__ ((unused,used)) signed int __f1__Fi___1();
     227__attribute__ ((unused)) signed int __f1__Fi___1(){
     228    __attribute__ ((unused)) signed int ___retval_f1__i_1;
     229}
     230__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FCPPi___1();
     231__attribute__ ((unused,unused,unused)) signed int **const __f2__FCPPi___1(){
     232    __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
     233}
     234__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object1))[];
     235__attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
     236    __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
     237}
     238__attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object2);
     239__attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object3){
     240    __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object4);
     241}
     242signed int __vtr__Fi___1(){
     243    __attribute__ ((unused)) signed int ___retval_vtr__i_1;
     244    __attribute__ ((unused,unused,used)) signed int __t1__i_2;
     245    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t2__PPi_2;
     246    __attribute__ ((unused,unused,unused)) signed int __t3__A0i_2[((unsigned long int )5)];
     247    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t4__A0PPi_2[((unsigned long int )5)];
     248    __attribute__ ((unused,unused,unused)) signed int __t5__Fi___2();
     249    __attribute__ ((unused,unused,unused,unused)) signed int *__t6__FPi___2();
     250}
     251signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1);
     252signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1){
     253    __attribute__ ((unused)) signed int ___retval_ipd1__i_1;
     254}
     255signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     256signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     257    __attribute__ ((unused)) signed int ___retval_ipd2__i_1;
     258}
     259signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     260signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     261    __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
     262}
     263signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)());
     264signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)()){
     265    __attribute__ ((unused)) signed int ___retval_ipd4__i_1;
     266}
     267signed int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) signed int __Foo__i_1);
     268signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
     269signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
     270signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object5)(__attribute__ ((unused,unused)) signed int __anonymous_object6[((unsigned long int )5)]));
     271signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
     272signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
     273signed 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)));
     274signed int __ad__Fi___1(){
     275    __attribute__ ((unused)) signed int ___retval_ad__i_1;
     276    __attribute__ ((used,unused)) signed int __ad1__i_2;
     277    __attribute__ ((unused,unused,unused)) signed int *__ad2__Pi_2;
     278    __attribute__ ((unused,unused,unused)) signed int __ad3__A0i_2[((unsigned long int )5)];
     279    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*__ad4__PA0i_2)[((unsigned long int )10)];
     280    __attribute__ ((unused,unused,unused,unused,used)) signed int __ad5__i_2;
     281    __attribute__ ((unused,unused,unused,unused,unused)) signed int __ad6__Fi___2();
     282    ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
     283    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
     284    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [5]));
     285    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[10]));
     286    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
    287287    __attribute__ ((unused)) struct __anonymous4 {
    288         int __i__i_2;
     288        signed int __i__i_2;
    289289    };
    290290    inline void ___constructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
     
    303303        return ((struct __anonymous4 )___ret__13s__anonymous4_2);
    304304    }
    305     inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, int __i__i_2){
     305    inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
    306306        ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
    307307    }
     
    324324    ((void)sizeof(enum __anonymous5 ));
    325325}
    326 int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object10, __attribute__ ((unused,unused,unused)) int *__anonymous_object11);
    327 int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) int **__anonymous_object13);
    328 int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object14, __attribute__ ((unused,unused,unused)) int *__anonymous_object15);
    329 int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) int (*__anonymous_object17)());
    330 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));
    331 int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) int (*__anonymous_object23)());
    332 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));
     326signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object10, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object11);
     327signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object13);
     328signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
     329signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)());
     330signed 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));
     331signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)());
     332signed 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));
    333333struct Vad {
    334     __attribute__ ((unused)) int __anonymous_object28;
    335     __attribute__ ((unused,unused)) int *__anonymous_object29;
    336     __attribute__ ((unused,unused)) int __anonymous_object30[((long unsigned int )10)];
    337     __attribute__ ((unused,unused)) int (*__anonymous_object31)();
     334    __attribute__ ((unused)) signed int __anonymous_object28;
     335    __attribute__ ((unused,unused)) signed int *__anonymous_object29;
     336    __attribute__ ((unused,unused)) signed int __anonymous_object30[((unsigned long int )10)];
     337    __attribute__ ((unused,unused)) signed int (*__anonymous_object31)();
    338338};
    339339static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
  • src/tests/.expect/64/declarationSpecifier.txt

    re3e16bc r982832e  
    1 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     1__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 volatile const short __x1__CVs_1;
    8 static volatile const short __x2__CVs_1;
    9 static volatile const short __x3__CVs_1;
    10 static volatile const short __x4__CVs_1;
    11 static volatile const short __x5__CVs_1;
    12 static volatile const short __x6__CVs_1;
    13 static volatile const short __x7__CVs_1;
    14 static volatile const short __x8__CVs_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7volatile const signed short int __x1__CVs_1;
     8static volatile const signed short int __x2__CVs_1;
     9static volatile const signed short int __x3__CVs_1;
     10static volatile const signed short int __x4__CVs_1;
     11static volatile const signed short int __x5__CVs_1;
     12static volatile const signed short int __x6__CVs_1;
     13static volatile const signed short int __x7__CVs_1;
     14static volatile const signed short int __x8__CVs_1;
    1515struct __anonymous0 {
    16     int __i__i_1;
     16    signed int __i__i_1;
    1717};
    1818static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
     
    3535    return ((struct __anonymous0 )___ret__13s__anonymous0_1);
    3636}
    37 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, int __i__i_1){
     37static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){
    3838    ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
    3939}
    4040volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
    4141struct __anonymous1 {
    42     int __i__i_1;
     42    signed int __i__i_1;
    4343};
    4444static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
     
    6161    return ((struct __anonymous1 )___ret__13s__anonymous1_1);
    6262}
    63 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, int __i__i_1){
     63static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){
    6464    ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
    6565}
    6666volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
    6767struct __anonymous2 {
    68     int __i__i_1;
     68    signed int __i__i_1;
    6969};
    7070static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
     
    8787    return ((struct __anonymous2 )___ret__13s__anonymous2_1);
    8888}
    89 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, int __i__i_1){
     89static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){
    9090    ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
    9191}
    9292volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
    9393struct __anonymous3 {
    94     int __i__i_1;
     94    signed int __i__i_1;
    9595};
    9696static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
     
    113113    return ((struct __anonymous3 )___ret__13s__anonymous3_1);
    114114}
    115 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, int __i__i_1){
     115static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){
    116116    ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
    117117}
    118118static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
    119119struct __anonymous4 {
    120     int __i__i_1;
     120    signed int __i__i_1;
    121121};
    122122static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
     
    139139    return ((struct __anonymous4 )___ret__13s__anonymous4_1);
    140140}
    141 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, int __i__i_1){
     141static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){
    142142    ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
    143143}
    144144static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
    145145struct __anonymous5 {
    146     int __i__i_1;
     146    signed int __i__i_1;
    147147};
    148148static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
     
    165165    return ((struct __anonymous5 )___ret__13s__anonymous5_1);
    166166}
    167 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, int __i__i_1){
     167static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){
    168168    ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
    169169}
    170170static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
    171171struct __anonymous6 {
    172     int __i__i_1;
     172    signed int __i__i_1;
    173173};
    174174static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
     
    191191    return ((struct __anonymous6 )___ret__13s__anonymous6_1);
    192192}
    193 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, int __i__i_1){
     193static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){
    194194    ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
    195195}
    196196static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
    197197struct __anonymous7 {
    198     int __i__i_1;
     198    signed int __i__i_1;
    199199};
    200200static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
     
    217217    return ((struct __anonymous7 )___ret__13s__anonymous7_1);
    218218}
    219 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, int __i__i_1){
     219static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){
    220220    ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
    221221}
    222222static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
    223 volatile const short __x20__CVs_1;
    224 static volatile const short __x21__CVs_1;
    225 static volatile const short __x22__CVs_1;
    226 static volatile const short __x23__CVs_1;
    227 static volatile const short __x24__CVs_1;
    228 static volatile const short __x25__CVs_1;
    229 static volatile const short __x26__CVs_1;
    230 static volatile const short __x27__CVs_1;
     223volatile const signed short int __x20__CVs_1;
     224static volatile const signed short int __x21__CVs_1;
     225static volatile const signed short int __x22__CVs_1;
     226static volatile const signed short int __x23__CVs_1;
     227static volatile const signed short int __x24__CVs_1;
     228static volatile const signed short int __x25__CVs_1;
     229static volatile const signed short int __x26__CVs_1;
     230static volatile const signed short int __x27__CVs_1;
    231231struct __anonymous8 {
    232     short __i__s_1;
     232    signed short int __i__s_1;
    233233};
    234234static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
     
    251251    return ((struct __anonymous8 )___ret__13s__anonymous8_1);
    252252}
    253 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, short __i__s_1){
     253static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){
    254254    ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
    255255}
    256256volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
    257257struct __anonymous9 {
    258     short __i__s_1;
     258    signed short int __i__s_1;
    259259};
    260260static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
     
    277277    return ((struct __anonymous9 )___ret__13s__anonymous9_1);
    278278}
    279 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, short __i__s_1){
     279static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){
    280280    ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
    281281}
    282282volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
    283283struct __anonymous10 {
    284     short __i__s_1;
     284    signed short int __i__s_1;
    285285};
    286286static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
     
    303303    return ((struct __anonymous10 )___ret__14s__anonymous10_1);
    304304}
    305 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, short __i__s_1){
     305static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){
    306306    ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
    307307}
    308308volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
    309309struct __anonymous11 {
    310     short __i__s_1;
     310    signed short int __i__s_1;
    311311};
    312312static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
     
    329329    return ((struct __anonymous11 )___ret__14s__anonymous11_1);
    330330}
    331 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, short __i__s_1){
     331static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){
    332332    ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
    333333}
    334334static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
    335335struct __anonymous12 {
    336     short __i__s_1;
     336    signed short int __i__s_1;
    337337};
    338338static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
     
    355355    return ((struct __anonymous12 )___ret__14s__anonymous12_1);
    356356}
    357 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, short __i__s_1){
     357static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){
    358358    ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
    359359}
    360360static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
    361361struct __anonymous13 {
    362     short __i__s_1;
     362    signed short int __i__s_1;
    363363};
    364364static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
     
    381381    return ((struct __anonymous13 )___ret__14s__anonymous13_1);
    382382}
    383 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, short __i__s_1){
     383static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){
    384384    ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
    385385}
    386386static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
    387387struct __anonymous14 {
    388     short __i__s_1;
     388    signed short int __i__s_1;
    389389};
    390390static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
     
    407407    return ((struct __anonymous14 )___ret__14s__anonymous14_1);
    408408}
    409 static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, short __i__s_1){
     409static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1){
    410410    ((void)((*___dst__R14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
    411411}
    412412static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1;
    413413struct __anonymous15 {
    414     short __i__s_1;
     414    signed short int __i__s_1;
    415415};
    416416static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1);
     
    433433    return ((struct __anonymous15 )___ret__14s__anonymous15_1);
    434434}
    435 static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, short __i__s_1){
     435static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1){
    436436    ((void)((*___dst__R14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
    437437}
    438438static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1;
    439 static inline volatile const int __f11__FCVi___1();
    440 static inline volatile const int __f12__FCVi___1();
    441 static inline volatile const int __f13__FCVi___1();
    442 static inline volatile const int __f14__FCVi___1();
    443 static inline volatile const int __f15__FCVi___1();
    444 static inline volatile const int __f16__FCVi___1();
    445 static inline volatile const int __f17__FCVi___1();
    446 static inline volatile const int __f18__FCVi___1();
    447 static inline volatile const short __f21__FCVs___1();
    448 static inline volatile const short __f22__FCVs___1();
    449 static inline volatile const short __f23__FCVs___1();
    450 static inline volatile const short __f24__FCVs___1();
    451 static inline volatile const short __f25__FCVs___1();
    452 static inline volatile const short __f26__FCVs___1();
    453 static inline volatile const short __f27__FCVs___1();
    454 static inline volatile const short __f28__FCVs___1();
     439static inline volatile const signed int __f11__FCVi___1();
     440static inline volatile const signed int __f12__FCVi___1();
     441static inline volatile const signed int __f13__FCVi___1();
     442static inline volatile const signed int __f14__FCVi___1();
     443static inline volatile const signed int __f15__FCVi___1();
     444static inline volatile const signed int __f16__FCVi___1();
     445static inline volatile const signed int __f17__FCVi___1();
     446static inline volatile const signed int __f18__FCVi___1();
     447static inline volatile const signed short int __f21__FCVs___1();
     448static inline volatile const signed short int __f22__FCVs___1();
     449static inline volatile const signed short int __f23__FCVs___1();
     450static inline volatile const signed short int __f24__FCVs___1();
     451static inline volatile const signed short int __f25__FCVs___1();
     452static inline volatile const signed short int __f26__FCVs___1();
     453static inline volatile const signed short int __f27__FCVs___1();
     454static inline volatile const signed short int __f28__FCVs___1();
    455455struct __anonymous16 {
    456     int __i__i_1;
     456    signed int __i__i_1;
    457457};
    458458static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1);
     
    475475    return ((struct __anonymous16 )___ret__14s__anonymous16_1);
    476476}
    477 static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, int __i__i_1){
     477static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1){
    478478    ((void)((*___dst__R14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */);
    479479}
    480480static inline volatile const struct __anonymous16 __f31__FCV14s__anonymous16___1();
    481481struct __anonymous17 {
    482     int __i__i_1;
     482    signed int __i__i_1;
    483483};
    484484static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1);
     
    501501    return ((struct __anonymous17 )___ret__14s__anonymous17_1);
    502502}
    503 static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, int __i__i_1){
     503static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1){
    504504    ((void)((*___dst__R14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */);
    505505}
    506506static inline volatile const struct __anonymous17 __f32__FCV14s__anonymous17___1();
    507507struct __anonymous18 {
    508     int __i__i_1;
     508    signed int __i__i_1;
    509509};
    510510static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1);
     
    527527    return ((struct __anonymous18 )___ret__14s__anonymous18_1);
    528528}
    529 static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, int __i__i_1){
     529static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1){
    530530    ((void)((*___dst__R14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */);
    531531}
    532532static inline volatile const struct __anonymous18 __f33__FCV14s__anonymous18___1();
    533533struct __anonymous19 {
    534     int __i__i_1;
     534    signed int __i__i_1;
    535535};
    536536static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1);
     
    553553    return ((struct __anonymous19 )___ret__14s__anonymous19_1);
    554554}
    555 static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, int __i__i_1){
     555static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1){
    556556    ((void)((*___dst__R14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */);
    557557}
    558558static inline volatile const struct __anonymous19 __f34__FCV14s__anonymous19___1();
    559559struct __anonymous20 {
    560     int __i__i_1;
     560    signed int __i__i_1;
    561561};
    562562static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1);
     
    579579    return ((struct __anonymous20 )___ret__14s__anonymous20_1);
    580580}
    581 static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, int __i__i_1){
     581static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1){
    582582    ((void)((*___dst__R14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */);
    583583}
    584584static inline volatile const struct __anonymous20 __f35__FCV14s__anonymous20___1();
    585585struct __anonymous21 {
    586     int __i__i_1;
     586    signed int __i__i_1;
    587587};
    588588static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1);
     
    605605    return ((struct __anonymous21 )___ret__14s__anonymous21_1);
    606606}
    607 static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, int __i__i_1){
     607static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1){
    608608    ((void)((*___dst__R14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */);
    609609}
    610610static inline volatile const struct __anonymous21 __f36__FCV14s__anonymous21___1();
    611611struct __anonymous22 {
    612     int __i__i_1;
     612    signed int __i__i_1;
    613613};
    614614static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1);
     
    631631    return ((struct __anonymous22 )___ret__14s__anonymous22_1);
    632632}
    633 static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, int __i__i_1){
     633static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1){
    634634    ((void)((*___dst__R14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */);
    635635}
    636636static inline volatile const struct __anonymous22 __f37__FCV14s__anonymous22___1();
    637637struct __anonymous23 {
    638     int __i__i_1;
     638    signed int __i__i_1;
    639639};
    640640static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1);
     
    657657    return ((struct __anonymous23 )___ret__14s__anonymous23_1);
    658658}
    659 static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, int __i__i_1){
     659static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1){
    660660    ((void)((*___dst__R14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */);
    661661}
    662662static inline volatile const struct __anonymous23 __f38__FCV14s__anonymous23___1();
    663 static inline volatile const short __f41__FCVs___1();
    664 static inline volatile const short __f42__FCVs___1();
    665 static inline volatile const short __f43__FCVs___1();
    666 static inline volatile const short __f44__FCVs___1();
    667 static inline volatile const short __f45__FCVs___1();
    668 static inline volatile const short __f46__FCVs___1();
    669 static inline volatile const short __f47__FCVs___1();
    670 static inline volatile const short __f48__FCVs___1();
    671 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
    672     __attribute__ ((unused)) int ___retval_main__i_1;
    673     ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
    674     return ((int )___retval_main__i_1);
     663static inline volatile const signed short int __f41__FCVs___1();
     664static inline volatile const signed short int __f42__FCVs___1();
     665static inline volatile const signed short int __f43__FCVs___1();
     666static inline volatile const signed short int __f44__FCVs___1();
     667static inline volatile const signed short int __f45__FCVs___1();
     668static inline volatile const signed short int __f46__FCVs___1();
     669static inline volatile const signed short int __f47__FCVs___1();
     670static inline volatile const signed short int __f48__FCVs___1();
     671signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     672    __attribute__ ((unused)) signed int ___retval_main__i_1;
     673    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     674    return ((signed int )___retval_main__i_1);
    675675    ((void)(___retval_main__i_1=0) /* ?{} */);
    676     return ((int )___retval_main__i_1);
     676    return ((signed int )___retval_main__i_1);
    677677}
    678678static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
    679 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     679__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    680680__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    681681__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    682 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    683 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    684 extern int printf(const char *__restrict __format, ...);
    685 static inline int invoke_main(int argc, char **argv, char **envp);
    686 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
    687     __attribute__ ((unused)) int ___retval_main__i_1;
    688     int _tmp_cp_ret0;
     682__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     683__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     684extern signed int printf(const char *__restrict __format, ...);
     685static inline signed int invoke_main(signed int argc, char **argv, char **envp);
     686signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     687    __attribute__ ((unused)) signed int ___retval_main__i_1;
     688    signed int _tmp_cp_ret0;
    689689    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
    690690    ((void)(_tmp_cp_ret0) /* ^?{} */);
    691     return ((int )___retval_main__i_1);
    692 }
     691    return ((signed int )___retval_main__i_1);
     692}
  • src/tests/.expect/64/extension.txt

    re3e16bc r982832e  
    1 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     1__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 __extension__ int __a__i_1;
    8 __extension__ int __b__i_1;
    9 __extension__ int __c__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7__extension__ signed int __a__i_1;
     8__extension__ signed int __b__i_1;
     9__extension__ signed int __c__i_1;
    1010__extension__ struct S {
    11     __extension__ int __a__i_1;
    12     __extension__ int __b__i_1;
    13     __extension__ int __c__i_1;
     11    __extension__ signed int __a__i_1;
     12    __extension__ signed int __b__i_1;
     13    __extension__ signed int __c__i_1;
    1414};
    1515static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
     
    4040    return ((struct S )___ret__2sS_1);
    4141}
    42 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __a__i_1){
     42static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
    4343    ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
    4444    ((void)((*___dst__R2sS_1).__b__i_1) /* ?{} */);
    4545    ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
    4646}
    47 static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1){
     47static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1){
    4848    ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
    4949    ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
    5050    ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
    5151}
    52 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){
     52static 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){
    5353    ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
    5454    ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     
    5656}
    5757__extension__ union U {
    58     __extension__ int __a__i_1;
    59     __extension__ int __b__i_1;
    60     __extension__ int __c__i_1;
     58    __extension__ signed int __a__i_1;
     59    __extension__ signed int __b__i_1;
     60    __extension__ signed int __c__i_1;
    6161};
    6262static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
     
    7373    return ((union U )___ret__2uU_1);
    7474}
    75 static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, int __src__i_1){
    76     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(int )));
     75static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, signed int __src__i_1){
     76    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(signed int )));
    7777}
    7878__extension__ enum E {
     
    8181    __B__C2eE_1,
    8282};
    83 __extension__ int __f__Fi___1();
    84 __extension__ int i;
    85 __extension__ int j;
    86 __extension__ int __fred__Fi_i__1(int __p__i_1){
    87     __attribute__ ((unused)) int ___retval_fred__i_1;
     83__extension__ signed int __f__Fi___1();
     84__extension__ signed int i;
     85__extension__ signed int j;
     86__extension__ signed int __fred__Fi_i__1(signed int __p__i_1){
     87    __attribute__ ((unused)) signed int ___retval_fred__i_1;
    8888    __extension__ struct S {
    89         __extension__ int __a__i_2;
    90         __extension__ int __b__i_2;
    91         __extension__ int __c__i_2;
    92         __extension__ int *__x__Pi_2;
    93         __extension__ int *__y__Pi_2;
    94         __extension__ int *__z__Pi_2;
     89        __extension__ signed int __a__i_2;
     90        __extension__ signed int __b__i_2;
     91        __extension__ signed int __c__i_2;
     92        __extension__ signed int *__x__Pi_2;
     93        __extension__ signed int *__y__Pi_2;
     94        __extension__ signed int *__z__Pi_2;
    9595    };
    96     int __i__i_2 = ((int )(__extension__ __a__i_1+__extension__ 3));
     96    signed int __i__i_2 = ((signed int )(__extension__ __a__i_1+__extension__ 3));
    9797    ((void)__extension__ 3);
    9898    ((void)__extension__ __a__i_1);
    99     __extension__ int __a__i_2;
    100     __extension__ int __b__i_2;
    101     __extension__ int __c__i_2;
     99    __extension__ signed int __a__i_2;
     100    __extension__ signed int __b__i_2;
     101    __extension__ signed int __c__i_2;
    102102    ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
    103     int _tmp_cp_ret0;
     103    signed int _tmp_cp_ret0;
    104104    ((void)(((void)(_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3))) , _tmp_cp_ret0));
    105105    ((void)(_tmp_cp_ret0) /* ^?{} */);
    106     __extension__ int __mary__Fi_i__2(int __p__i_2){
    107         __attribute__ ((unused)) int ___retval_mary__i_2;
     106    __extension__ signed int __mary__Fi_i__2(signed int __p__i_2){
     107        __attribute__ ((unused)) signed int ___retval_mary__i_2;
    108108    }
    109109    ((void)__extension__ sizeof(3));
    110     ((void)__extension__ (((int )(3!=((int )0))) || ((int )(4!=((int )0)))));
     110    ((void)__extension__ (((signed int )(3!=((signed int )0))) || ((signed int )(4!=((signed int )0)))));
    111111    ((void)__extension__ __alignof__(__extension__ __a__i_2));
    112     ((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)))));
    113     ((void)(((int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
     112    ((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)))));
     113    ((void)(((signed int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
    114114    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
    115115    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
  • src/tests/.expect/64/gccExtensions.txt

    re3e16bc r982832e  
    1 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     1__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 extern int __x__i_1 asm ( "xx" );
    8 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
    9     __attribute__ ((unused)) int ___retval_main__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7extern signed int __x__i_1 asm ( "xx" );
     8signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     9    __attribute__ ((unused)) signed int ___retval_main__i_1;
    1010    asm ( "nop" :  :  :  );
    1111    asm ( "nop" :  :  :  );
    1212    asm ( "nop" :  :  :  );
    13     static int __y__i_2 asm ( "yy" );
    14     static int *__z__Pi_2 asm ( "zz" );
    15     int __src__i_2;
    16     int __dst__i_2;
    17     asm volatile ( "mov %1, %0\n\tadd $1, %0" :  :  :  );
    18     asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) :  :  );
    19     asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
    20     asm ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
     13    static signed int __y__i_2 asm ( "yy" );
     14    static signed int *__z__Pi_2 asm ( "zz" );
     15    signed int __src__i_2;
     16    signed int __dst__i_2;
     17    asm volatile ( "mov %1, %0\n\t" "add $1, %0" :  :  :  );
     18    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( __dst__i_2 ) :  :  );
     19    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
     20    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" );
    2121    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 );
    2222    double _Complex __c1__Xd_2;
    2323    double _Complex __c2__Xd_2;
    24     const int __i1__Ci_2;
    25     const int __i2__Ci_2;
    26     const int __i3__Ci_2;
    27     inline int __f1__Fi___2(){
    28         __attribute__ ((unused)) int ___retval_f1__i_2;
     24    const signed int __i1__Ci_2;
     25    const signed int __i2__Ci_2;
     26    const signed int __i3__Ci_2;
     27    inline signed int __f1__Fi___2(){
     28        __attribute__ ((unused)) signed int ___retval_f1__i_2;
    2929    }
    30     inline int __f2__Fi___2(){
    31         __attribute__ ((unused)) int ___retval_f2__i_2;
     30    inline signed int __f2__Fi___2(){
     31        __attribute__ ((unused)) signed int ___retval_f2__i_2;
    3232    }
    33     int __s1__i_2;
    34     int __s2__i_2;
    35     volatile int __v1__Vi_2;
    36     volatile int __v2__Vi_2;
    37     int __t1___2;
    38     int __t2___2;
    39     __extension__ const int __ex__Ci_2;
     33    signed int __s1__i_2;
     34    signed int __s2__i_2;
     35    volatile signed int __v1__Vi_2;
     36    volatile signed int __v2__Vi_2;
     37    signed int __t1___2;
     38    signed int __t2___2;
     39    __extension__ const signed int __ex__Ci_2;
    4040    struct S {
    41         __extension__ int __a__i_2;
    42         __extension__ int __b__i_2;
    43         __extension__ int __c__i_2;
     41        __extension__ signed int __a__i_2;
     42        __extension__ signed int __b__i_2;
     43        __extension__ signed int __c__i_2;
    4444    };
    4545    inline void ___constructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
     
    6666        return ((struct S )___ret__2sS_2);
    6767    }
    68     inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, int __a__i_2){
     68    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
    6969        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
    7070        ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
    7171        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
    7272    }
    73     inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2){
     73    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2){
    7474        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
    7575        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
    7676        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
    7777    }
    78     inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2, int __c__i_2){
     78    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){
    7979        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
    8080        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
    8181        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
    8282    }
    83     int __i__i_2 = ((int )__extension__ 3);
    84     __extension__ int __a__i_2;
    85     __extension__ int __b__i_2;
    86     __extension__ int __c__i_2;
     83    signed int __i__i_2 = ((signed int )__extension__ 3);
     84    __extension__ signed int __a__i_2;
     85    __extension__ signed int __b__i_2;
     86    __extension__ signed int __c__i_2;
    8787    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
    8888    ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
    8989    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
    90     int __a1__i_2;
    91     const int __a2__Ci_2;
    92     static const int __a3__Ci_2;
    93     static const int __a4__Ci_2;
    94     static const int __a5__Ci_2;
    95     static const int __a6__Ci_2;
    96     static const int __a7__Ci_2;
    97     int *__p1__Pi_2;
    98     int *__p2__Pi_2;
     90    signed int __a1__i_2;
     91    const signed int __a2__Ci_2;
     92    static const signed int __a3__Ci_2;
     93    static const signed int __a4__Ci_2;
     94    static const signed int __a5__Ci_2;
     95    static const signed int __a6__Ci_2;
     96    static const signed int __a7__Ci_2;
     97    signed int *__p1__Pi_2;
     98    signed int *__p2__Pi_2;
    9999    struct s1;
    100100    struct s2 {
    101         int __i__i_2;
     101        signed int __i__i_2;
    102102    };
    103103    inline void ___constructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){
     
    116116        return ((struct s2 )___ret__3ss2_2);
    117117    }
    118     inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, int __i__i_2){
     118    inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
    119119        ((void)((*___dst__R3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
    120120    }
    121121    struct s3 {
    122         int __i__i_2;
     122        signed int __i__i_2;
    123123    };
    124124    inline void ___constructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){
     
    137137        return ((struct s3 )___ret__3ss3_2);
    138138    }
    139     inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, int __i__i_2){
     139    inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
    140140        ((void)((*___dst__R3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
    141141    }
     
    143143    struct s3 __y1__3ss3_2;
    144144    struct s4 {
    145         int __i__i_2;
     145        signed int __i__i_2;
    146146    };
    147147    inline void ___constructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){
     
    160160        return ((struct s4 )___ret__3ss4_2);
    161161    }
    162     inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, int __i__i_2){
     162    inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
    163163        ((void)((*___dst__R3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
    164164    }
    165165    struct s4 __x2__3ss4_2;
    166166    struct s4 __y2__3ss4_2;
    167     int __m1__A0i_2[((long unsigned int )10)];
    168     int __m2__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)];
    169     int __m3__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)];
    170     ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
    171     return ((int )___retval_main__i_1);
     167    signed int __m1__A0i_2[((unsigned long int )10)];
     168    signed int __m2__A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
     169    signed int __m3__A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
     170    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     171    return ((signed int )___retval_main__i_1);
    172172    ((void)(___retval_main__i_1=0) /* ?{} */);
    173     return ((int )___retval_main__i_1);
     173    return ((signed int )___retval_main__i_1);
    174174}
    175175static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
    176 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     176__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    177177__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    178178__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    179 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    180 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    181 extern int printf(const char *__restrict __format, ...);
    182 static inline int invoke_main(int argc, char **argv, char **envp);
    183 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
    184     __attribute__ ((unused)) int ___retval_main__i_1;
    185     int _tmp_cp_ret0;
     179__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     180__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     181extern signed int printf(const char *__restrict __format, ...);
     182static inline signed int invoke_main(signed int argc, char **argv, char **envp);
     183signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     184    __attribute__ ((unused)) signed int ___retval_main__i_1;
     185    signed int _tmp_cp_ret0;
    186186    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
    187187    ((void)(_tmp_cp_ret0) /* ^?{} */);
    188     return ((int )___retval_main__i_1);
     188    return ((signed int )___retval_main__i_1);
    189189}
  • src/tests/.expect/io.txt

    re3e16bc r982832e  
    2727
    2828output basic types
    29 A
     29A 23 93
    30301 2 3 4 5 6 7 8
    31311.1 1.2 1.3
  • src/tests/.expect/user_literals.txt

    re3e16bc r982832e  
    5511.0714285714286
    6622.0457142857143
     7secs 1
     8secs 23
     9mins 23
     10hours 23
     11_A_ 23
     12_thingy_ 1234
     13secs 65535
     14mins 65535
     15hours 65535
     16_A_ 65535
     17_thingy_ 65535
     18secs 10
     19hours 10
     20mins 10
     21_A_ 10
     22_thingy_ 10
     23secs abc
     24mins
     25hours abc
     26_A_ abc
     27_thingy_ abc
  • src/tests/Makefile.am

    re3e16bc r982832e  
    1111## Created On       : Sun May 31 09:08:15 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Thu Jun  8 07:41:43 2017
    14 ## Update Count     : 44
     13## Last Modified On : Mon Sep 11 16:17:16 2017
     14## Update Count     : 45
    1515###############################################################################
    1616
     
    101101        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
    102102
     103literals : literals.c @CFA_BINDIR@/@CFA_NAME@
     104        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
     105
    103106gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
    104107        ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}
  • src/tests/Makefile.in

    re3e16bc r982832e  
    853853        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
    854854
     855literals : literals.c @CFA_BINDIR@/@CFA_NAME@
     856        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
     857
    855858gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
    856859        ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}
  • src/tests/io.c

    re3e16bc r982832e  
    1010// Created On       : Wed Mar  2 16:56:02 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 23 21:27:50 2017
    13 // Update Count     : 79
     12// Last Modified On : Mon Sep 11 08:53:41 2017
     13// Update Count     : 81
    1414//
    1515
     
    1818int main() {
    1919        char c;                                                                                         // basic types
     20        signed char sc;
     21        unsigned char usc;
    2022        short int si;
    2123        unsigned short int usi;
     
    8991
    9092        sout | "input bacis types" | endl;
    91         &in | c                                                                                         // character
     93        &in | c | sc | usc                                                                      // character
    9294                | si | usi | i | ui | li | uli | lli | ulli             // integral
    9395                | f | d | ld                                                                    // floating point
     
    9799
    98100        sout | "output basic types" | endl;
    99         sout | c | ' ' | endl                                                           // character
     101        sout | c | ' ' | sc | ' ' | usc | endl                          // character
    100102                | si | usi | i | ui | li | uli | lli | ulli | endl // integral
    101103                | f | d | ld | endl                                                             // floating point
  • src/tests/io.data

    re3e16bc r982832e  
    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
     1A 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

    re3e16bc r982832e  
    1010// Created On       : Wed Sep  6 21:40:50 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Sep  6 23:19:08 2017
    13 // Update Count     : 36
     12// Last Modified On : Sat Sep  9 08:31:32 2017
     13// Update Count     : 48
    1414//
    1515
    1616#include <fstream>
     17#include <wchar.h>
     18#include <uchar.h>
     19
     20int ?`s( int s ) { sout | "secs" | s | endl; return s; }
     21int ?`m( int m ) { sout | "mins" | m | endl; return m * 60; }
     22int ?`h( int h ) { sout | "hours" | h | endl; return h * 3600; }
     23int ?`_A_( int x ) { sout | "_A_" | x | endl; return x; }
     24int ?`__thingy_( int x ) { sout | "_thingy_" | x | endl; return x; }
     25
     26int ?`s( const char * s ) { sout | "secs" | s | endl; return 0; }
     27int ?`m( const char16_t * m ) { sout | "mins" | m | endl; return 0;}
     28int ?`h( const char32_t * h ) { sout | "hours" | h | endl; return 0; }
     29int ?`_A_( const wchar_t * str ) { sout | "_A_" | str | endl; return 0; }
     30int ?`__thingy_( const char * str ) { sout | "_thingy_" | str | endl; return 0; }
     31
    1732
    1833struct Weight {
    19     double stones;
     34        double stones;
    2035};
    21 void ?{}( Weight & w ) { w.stones = 0; }        // constructors
     36void ?{}( Weight & w ) { w.stones = 0; }                                // operations
    2237void ?{}( Weight & w, double w ) { w.stones = w; }
    23 
    2438Weight ?+?( Weight l, Weight r ) { return (Weight){ l.stones + r.stones }; }
    2539ofstream * ?|?( ofstream * os, Weight w ) { return os | w.stones; }
    2640
    27 Weight ?`st( double w ) { return (Weight){ w }; } // user literals
     41Weight ?`st( double w ) { return (Weight){ w }; }               // backquote for user literals
    2842Weight ?`lb( double w ) { return (Weight){ w / 14.0 }; }
    2943Weight ?`kg( double w ) { return (Weight) { w * 0.1575}; }
    3044
     45
    3146int main() {
    32     Weight w, hw = { 14 };
    33     w = 11`st + 1`lb;
    34     sout | w | endl;
    35     w = 70.3`kg;
    36     sout | w | endl;
    37     w = 155`lb;
    38     sout | w | endl;
    39     w = 0x9b`lb;                // hexadecimal weight
    40     sout | w | endl;
    41     w = 0233`lb;                // octal weight
    42     sout | w | endl;
    43     w = 5`st + 8`kg + 25`lb + hw;
    44     sout | w | endl;
    45 }
     47        Weight w, hw = { 14 };                                                          // 14 stone
     48        w = 11`st + 1`lb;
     49        sout | w | endl;
     50        w = 70.3`kg;
     51        sout | w | endl;
     52        w = 155`lb;
     53        sout | w | endl;
     54        w = 0x_9b_u`lb;                                                                         // hexadecimal unsigned weight (155)
     55        sout | w | endl;
     56        w = 0_233`lb;                                                                           // octal weight (155)
     57        sout | w | endl;
     58        w = 5`st + 8`kg + 25`lb + hw;
     59        sout | w | endl;
    4660
     61//      0`secs;
     62        1`s;
     63        23`s;
     64        23u`m;
     65        23l`h;
     66        23_ul`_A_;
     67        1_234_LL`__thingy_;
    4768
     69        0xff_ffl;
     70        0xff_ff`s;
     71        0xff_ffu`m;
     72        0xff_ffl`h;
     73        0xff_fful`_A_;
     74        0xff_ffLL`__thingy_;
     75
     76        '\n'`s;
     77        L'\n'`h;
     78        u'\n'`m;
     79        L_'\n'`_A_;
     80        U_'\n'`__thingy_;
     81
     82        "abc"`s;
     83        u"abc"`m;
     84        U_"abc"`h;
     85        L"abc"`_A_;
     86        u8_"abc"`__thingy_;
     87} // main
    4888
    4989// Local Variables: //
Note: See TracChangeset for help on using the changeset viewer.