Changeset 777ed2b


Ignore:
Timestamp:
Jul 11, 2018, 11:55:59 AM (3 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer
Children:
0fc52b6
Parents:
fc20514 (diff), 7de22b28 (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:

fix conflicts

Location:
src
Files:
4 added
27 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    rfc20514 r777ed2b  
    164164                previsit( (BaseSyntaxNode *)node );
    165165                GuardAction( [this, node](){
    166                         if ( printExprTypes ) {
     166                        if ( printExprTypes && node->result ) {
    167167                                output << " /* " << genType( node->result, "", pretty, genC ) << " */ ";
    168168                        }
     
    224224
    225225        void CodeGenerator::handleAggregate( AggregateDecl * aggDecl, const std::string & kind ) {
    226                 if( ! aggDecl->get_parameters().empty() && ! genC ) {
     226                if( ! aggDecl->parameters.empty() && ! genC ) {
    227227                        // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
    228228                        output << "forall(";
    229                         genCommaList( aggDecl->get_parameters().begin(), aggDecl->get_parameters().end() );
     229                        genCommaList( aggDecl->parameters.begin(), aggDecl->parameters.end() );
    230230                        output << ")" << endl;
    231231                        output << indent;
     
    233233
    234234                output << kind;
    235                 genAttributes( aggDecl->get_attributes() );
    236                 output << aggDecl->get_name();
     235                genAttributes( aggDecl->attributes );
     236                output << aggDecl->name;
    237237
    238238                if ( aggDecl->has_body() ) {
    239                         std::list< Declaration * > & memb = aggDecl->get_members();
     239                        std::list< Declaration * > & memb = aggDecl->members;
    240240                        output << " {" << endl;
    241241
  • src/CodeGen/GenType.cc

    rfc20514 r777ed2b  
    4848                void postvisit( ZeroType * zeroType );
    4949                void postvisit( OneType * oneType );
     50                void postvisit( GlobalScopeType * globalType );
    5051                void postvisit( TraitInstType * inst );
    5152                void postvisit( TypeofType * typeof );
     53                void postvisit( QualifiedType * qualType );
    5254
    5355          private:
     
    291293        }
    292294
     295        void GenType::postvisit( GlobalScopeType * globalType ) {
     296                assertf( ! genC, "Global scope type should not reach code generation." );
     297                handleQualifiers( globalType );
     298        }
     299
    293300        void GenType::postvisit( TraitInstType * inst ) {
    294301                assertf( ! genC, "Trait types should not reach code generation." );
     
    307314        }
    308315
     316        void GenType::postvisit( QualifiedType * qualType ) {
     317                assertf( ! genC, "Qualified types should not reach code generation." );
     318                std::ostringstream os;
     319                os << genType( qualType->parent, "", pretty, genC, lineMarks ) << "." << genType( qualType->child, "", pretty, genC, lineMarks ) << typeString;
     320                typeString = os.str();
     321                handleQualifiers( qualType );
     322        }
     323
    309324        void GenType::handleQualifiers( Type * type ) {
    310325                if ( type->get_const() ) {
  • src/Common/PassVisitor.h

    rfc20514 r777ed2b  
    133133        virtual void visit( ArrayType * arrayType ) override final;
    134134        virtual void visit( ReferenceType * referenceType ) override final;
     135        virtual void visit( QualifiedType * qualType ) override final;
    135136        virtual void visit( FunctionType * functionType ) override final;
    136137        virtual void visit( StructInstType * aggregateUseType ) override final;
     
    145146        virtual void visit( ZeroType * zeroType ) override final;
    146147        virtual void visit( OneType * oneType ) override final;
     148        virtual void visit( GlobalScopeType * globalType ) override final;
    147149
    148150        virtual void visit( Designation * designation ) override final;
     
    233235        virtual Type * mutate( ArrayType * arrayType ) override final;
    234236        virtual Type * mutate( ReferenceType * referenceType ) override final;
     237        virtual Type * mutate( QualifiedType * qualType ) override final;
    235238        virtual Type * mutate( FunctionType * functionType ) override final;
    236239        virtual Type * mutate( StructInstType * aggregateUseType ) override final;
     
    245248        virtual Type * mutate( ZeroType * zeroType ) override final;
    246249        virtual Type * mutate( OneType * oneType ) override final;
     250        virtual Type * mutate( GlobalScopeType * globalType ) override final;
    247251
    248252        virtual Designation * mutate( Designation * designation ) override final;
  • src/Common/PassVisitor.impl.h

    rfc20514 r777ed2b  
    22622262
    22632263//--------------------------------------------------------------------------
     2264// QualifiedType
     2265template< typename pass_type >
     2266void PassVisitor< pass_type >::visit( QualifiedType * node ) {
     2267        VISIT_START( node );
     2268
     2269        maybeAccept_impl( node->forall, *this );
     2270        maybeAccept_impl( node->parent, *this );
     2271        maybeAccept_impl( node->child, *this );
     2272
     2273        VISIT_END( node );
     2274}
     2275
     2276template< typename pass_type >
     2277Type * PassVisitor< pass_type >::mutate( QualifiedType * node ) {
     2278        MUTATE_START( node );
     2279
     2280        maybeMutate_impl( node->forall, *this );
     2281        maybeMutate_impl( node->parent, *this );
     2282        maybeMutate_impl( node->child, *this );
     2283
     2284        MUTATE_END( Type, node );
     2285}
     2286
     2287//--------------------------------------------------------------------------
    22642288// FunctionType
    22652289template< typename pass_type >
     
    25542578
    25552579//--------------------------------------------------------------------------
     2580// GlobalScopeType
     2581template< typename pass_type >
     2582void PassVisitor< pass_type >::visit( GlobalScopeType * node ) {
     2583        VISIT_START( node );
     2584
     2585        maybeAccept_impl( node->forall, *this );
     2586
     2587        VISIT_END( node );
     2588}
     2589
     2590template< typename pass_type >
     2591Type * PassVisitor< pass_type >::mutate( GlobalScopeType * node ) {
     2592        MUTATE_START( node );
     2593
     2594        maybeMutate_impl( node->forall, *this );
     2595
     2596        MUTATE_END( Type, node );
     2597}
     2598
     2599//--------------------------------------------------------------------------
    25562600// Designation
    25572601template< typename pass_type >
  • src/Concurrency/Keywords.cc

    rfc20514 r777ed2b  
    501501        void MutexKeyword::postvisit(StructDecl* decl) {
    502502
    503                 if( decl->name == "monitor_desc" ) {
     503                if( decl->name == "monitor_desc" && decl->body ) {
    504504                        assert( !monitor_decl );
    505505                        monitor_decl = decl;
    506506                }
    507                 else if( decl->name == "monitor_guard_t" ) {
     507                else if( decl->name == "monitor_guard_t" && decl->body ) {
    508508                        assert( !guard_decl );
    509509                        guard_decl = decl;
    510510                }
    511                 else if( decl->name == "monitor_dtor_guard_t" ) {
     511                else if( decl->name == "monitor_dtor_guard_t" && decl->body ) {
    512512                        assert( !dtor_guard_decl );
    513513                        dtor_guard_decl = decl;
  • src/InitTweak/FixInit.cc

    rfc20514 r777ed2b  
    11631163
    11641164                        std::string fname = getFunctionName( appExpr );
    1165                         if ( fname == function->get_name() ) {
     1165                        if ( fname == function->name ) {
    11661166                                // call to same kind of function
    1167                                 Expression * firstParam = appExpr->get_args().front();
     1167                                Expression * firstParam = appExpr->args.front();
    11681168
    11691169                                if ( isThisExpression( firstParam, thisParam ) ) {
     
    11741174                                        // if first parameter is a member expression on the this parameter,
    11751175                                        // then remove the member from unhandled set.
    1176                                         if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
    1177                                                 unhandled.erase( memberExpr->get_member() );
     1176                                        if ( isThisExpression( memberExpr->aggregate, thisParam ) ) {
     1177                                                unhandled.erase( memberExpr->member );
    11781178                                        }
    11791179                                }
  • src/Parser/DeclarationNode.cc

    rfc20514 r777ed2b  
    254254} // DeclarationNode::newFromTypedef
    255255
     256DeclarationNode * DeclarationNode::newFromGlobalScope() {
     257        DeclarationNode * newnode = new DeclarationNode;
     258        newnode->type = new TypeData( TypeData::GlobalScope );
     259        return newnode;
     260}
     261
     262DeclarationNode * DeclarationNode::newQualifiedType( DeclarationNode * parent, DeclarationNode * child) {
     263        DeclarationNode * newnode = new DeclarationNode;
     264        newnode->type = new TypeData( TypeData::Qualified );
     265        newnode->type->qualified.parent = parent->type;
     266        newnode->type->qualified.child = child->type;
     267        parent->type = nullptr;
     268        child->type = nullptr;
     269        delete parent;
     270        delete child;
     271        return newnode;
     272}
     273
    256274DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
    257         assert( name );
    258275        DeclarationNode * newnode = new DeclarationNode;
    259276        newnode->type = new TypeData( TypeData::Aggregate );
    260277        newnode->type->aggregate.kind = kind;
    261         newnode->type->aggregate.name = name;
     278        newnode->type->aggregate.name =  name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
    262279        newnode->type->aggregate.actuals = actuals;
    263280        newnode->type->aggregate.fields = fields;
     
    265282        newnode->type->aggregate.tagged = false;
    266283        newnode->type->aggregate.parent = nullptr;
     284        newnode->type->aggregate.anon = name == nullptr;
    267285        return newnode;
    268286} // DeclarationNode::newAggregate
    269287
    270288DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body ) {
    271         assert( name );
    272289        DeclarationNode * newnode = new DeclarationNode;
    273290        newnode->type = new TypeData( TypeData::Enum );
    274         newnode->type->enumeration.name = name;
     291        newnode->type->enumeration.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
    275292        newnode->type->enumeration.constants = constants;
    276293        newnode->type->enumeration.body = body;
     294        newnode->type->enumeration.anon = name == nullptr;
    277295        return newnode;
    278296} // DeclarationNode::newEnum
     
    953971        for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
    954972                try {
     973                        bool extracted = false;
     974                        bool anon = false;
    955975                        if ( DeclarationNode * extr = cur->extractAggregate() ) {
    956976                                // handle the case where a structure declaration is contained within an object or type declaration
    957977                                Declaration * decl = extr->build();
    958978                                if ( decl ) {
     979                                        // hoist the structure declaration
    959980                                        decl->location = cur->location;
    960981                                        * out++ = decl;
     982
     983                                        // need to remember the cases where a declaration contains an anonymous aggregate definition
     984                                        extracted = true;
     985                                        assert( extr->type );
     986                                        if ( extr->type->kind == TypeData::Aggregate ) {
     987                                                anon = extr->type->aggregate.anon;
     988                                        } else if ( extr->type->kind == TypeData::Enum ) {
     989                                                // xxx - is it useful to have an implicit anonymous enum member?
     990                                                anon = extr->type->enumeration.anon;
     991                                        }
    961992                                } // if
    962993                                delete extr;
     
    965996                        Declaration * decl = cur->build();
    966997                        if ( decl ) {
    967                                 decl->location = cur->location;
    968                                 * out++ = decl;
     998                                // don't include anonymous declaration for named aggregates, but do include them for anonymous aggregates, e.g.:
     999                                // struct S {
     1000                                //   struct T { int x; }; // no anonymous member
     1001                                //   struct { int y; };   // anonymous member
     1002                                //   struct T;            // anonymous member
     1003                                // };
     1004                                if ( ! (extracted && decl->name == "" && ! anon) ) {
     1005                                        decl->location = cur->location;
     1006                                        * out++ = decl;
     1007                                }
    9691008                        } // if
    9701009                } catch( SemanticErrorException &e ) {
     
    9781017} // buildList
    9791018
     1019// currently only builds assertions, function parameters, and return values
    9801020void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) {
    9811021        SemanticErrorException errors;
     
    9851025                try {
    9861026                        Declaration * decl = cur->build();
    987                         if ( decl ) {
    988                                 if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
    989                                         dwt->location = cur->location;
    990                                         * out++ = dwt;
    991                                 } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
    992                                         StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
    993                                         auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
    994                                         obj->location = cur->location;
    995                                         * out++ = obj;
    996                                         delete agg;
    997                                 } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
    998                                         UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
    999                                         auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
    1000                                         obj->location = cur->location;
    1001                                         * out++ = obj;
    1002                                 } // if
     1027                        assert( decl );
     1028                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
     1029                                dwt->location = cur->location;
     1030                                * out++ = dwt;
     1031                        } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
     1032                                // e.g., int foo(struct S) {}
     1033                                StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->name );
     1034                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
     1035                                obj->location = cur->location;
     1036                                * out++ = obj;
     1037                                delete agg;
     1038                        } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
     1039                                // e.g., int foo(union U) {}
     1040                                UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->name );
     1041                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
     1042                                obj->location = cur->location;
     1043                                * out++ = obj;
     1044                        } else if ( EnumDecl * agg = dynamic_cast< EnumDecl * >( decl ) ) {
     1045                                // e.g., int foo(enum E) {}
     1046                                EnumInstType * inst = new EnumInstType( Type::Qualifiers(), agg->name );
     1047                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
     1048                                obj->location = cur->location;
     1049                                * out++ = obj;
    10031050                        } // if
    10041051                } catch( SemanticErrorException &e ) {
  • src/Parser/ParseNode.h

    rfc20514 r777ed2b  
    231231        static DeclarationNode * newForall( DeclarationNode * );
    232232        static DeclarationNode * newFromTypedef( const std::string * );
     233        static DeclarationNode * newFromGlobalScope();
     234        static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
    233235        static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
    234236        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
  • src/Parser/TypeData.cc

    rfc20514 r777ed2b  
    3737          case Reference:
    3838          case EnumConstant:
     39          case GlobalScope:
    3940                // nothing else to initialize
    4041                break;
     
    6263                enumeration.constants = nullptr;
    6364                enumeration.body = false;
     65                enumeration.anon = false;
    6466                break;
    6567          case Aggregate:
     
    7375                aggregate.tagged = false;
    7476                aggregate.parent = nullptr;
     77                aggregate.anon = false;
    7578                break;
    7679          case AggregateInst:
     
    98101          case Builtin:
    99102                // builtin = new Builtin_t;
     103                case Qualified:
     104                qualified.parent = nullptr;
     105                qualified.child = nullptr;
    100106                break;
    101107        } // switch
     
    112118          case Reference:
    113119          case EnumConstant:
     120          case GlobalScope:
    114121                // nothing to destroy
    115122                break;
     
    165172                // delete builtin;
    166173                break;
     174          case Qualified:
     175                delete qualified.parent;
     176                delete qualified.child;
    167177        } // switch
    168178} // TypeData::~TypeData
     
    180190          case Pointer:
    181191          case Reference:
     192          case GlobalScope:
    182193                // nothing else to copy
    183194                break;
     
    207218                newtype->aggregate.fields = maybeClone( aggregate.fields );
    208219                newtype->aggregate.body = aggregate.body;
     220                newtype->aggregate.anon = aggregate.anon;
    209221                newtype->aggregate.tagged = aggregate.tagged;
    210222                newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
     
    219231                newtype->enumeration.constants = maybeClone( enumeration.constants );
    220232                newtype->enumeration.body = enumeration.body;
     233                newtype->enumeration.anon = enumeration.anon;
    221234                break;
    222235          case Symbolic:
     
    238251                newtype->builtintype = builtintype;
    239252                break;
     253                case Qualified:
     254                newtype->qualified.parent = maybeClone( qualified.parent );
     255                newtype->qualified.child = maybeClone( qualified.child );
     256                break;
    240257        } // switch
    241258        return newtype;
     
    406423        } // switch
    407424} // TypeData::print
     425
     426const std::string * TypeData::leafName() const {
     427        switch ( kind ) {
     428          case Unknown:
     429          case Pointer:
     430          case Reference:
     431          case EnumConstant:
     432          case GlobalScope:
     433          case Array:
     434          case Basic:
     435          case Function:
     436          case AggregateInst:
     437          case Tuple:
     438          case Typeof:
     439          case Builtin:
     440                assertf(false, "Tried to get leaf name from kind without a name: %d", kind);
     441                break;
     442          case Aggregate:
     443                return aggregate.name;
     444          case Enum:
     445                return enumeration.name;
     446          case Symbolic:
     447          case SymbolicInst:
     448                return symbolic.name;
     449          case Qualified:
     450                return qualified.child->leafName();
     451        } // switch
     452        assert(false);
     453}
    408454
    409455
     
    465511                return new EnumInstType( buildQualifiers( td ), "" );
    466512          case TypeData::SymbolicInst:
    467                 return buildSymbolicInst( td );;
     513                return buildSymbolicInst( td );
    468514          case TypeData::Tuple:
    469515                return buildTuple( td );
     
    480526                        return new VarArgsType( buildQualifiers( td ) );
    481527                }
     528          case TypeData::GlobalScope:
     529                return new GlobalScopeType();
     530                case TypeData::Qualified:
     531                return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
    482532          case TypeData::Symbolic:
    483533          case TypeData::Enum:
     
    485535                assert( false );
    486536        } // switch
     537
    487538        return nullptr;
    488539} // typebuild
     
    893944        assert( td->kind == TypeData::Function );
    894945        FunctionType * ft = new FunctionType( buildQualifiers( td ), ! td->function.params || td->function.params->hasEllipsis );
    895         buildList( td->function.params, ft->get_parameters() );
    896         buildForall( td->forall, ft->get_forall() );
     946        buildList( td->function.params, ft->parameters );
     947        buildForall( td->forall, ft->forall );
    897948        if ( td->base ) {
    898949                switch ( td->base->kind ) {
    899950                  case TypeData::Tuple:
    900                         buildList( td->base->tuple, ft->get_returnVals() );
     951                        buildList( td->base->tuple, ft->returnVals );
    901952                        break;
    902953                  default:
  • src/Parser/TypeData.h

    rfc20514 r777ed2b  
    2727struct TypeData {
    2828        enum Kind { Basic, Pointer, Array, Reference, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
    29                                 SymbolicInst, Tuple, Typeof, Builtin, Unknown };
     29                                SymbolicInst, Tuple, Typeof, Builtin, GlobalScope, Qualified, Unknown };
    3030
    3131        struct Aggregate_t {
     
    3636                DeclarationNode * fields;
    3737                bool body;
     38                bool anon;
    3839
    3940                bool tagged;
     
    5758                DeclarationNode * constants;
    5859                bool body;
     60                bool anon;
    5961        };
    6062
     
    7577        };
    7678
     79        struct Qualified_t { // qualified type S.T
     80                TypeData * parent;
     81                TypeData * child;
     82        };
     83
    7784        CodeLocation location;
    7885
     
    8895        DeclarationNode * forall;
    8996
    90         // Basic_t basic;
    9197        Aggregate_t aggregate;
    9298        AggInst_t aggInst;
    9399        Array_t array;
    94100        Enumeration_t enumeration;
    95         // Variable_t variable;
    96101        Function_t function;
    97102        Symbolic_t symbolic;
     103        Qualified_t qualified;
    98104        DeclarationNode * tuple;
    99105        ExpressionNode * typeexpr;
     
    103109        void print( std::ostream &, int indent = 0 ) const;
    104110        TypeData * clone() const;
     111
     112        const std::string * leafName() const;
    105113};
    106114
  • src/Parser/parser.yy

    rfc20514 r777ed2b  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jul 11 11:20:51 2018
    13 // Update Count     : 3738
     12// Last Modified On : Wed Jul 11 11:55:24 2018
     13// Update Count     : 3739
    1414//
    1515
     
    18251825                { $$ = DeclarationNode::newFromTypedef( $1 ); }
    18261826        | '.' TYPEDEFname
    1827                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     1827                { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), DeclarationNode::newFromTypedef( $2 ) ); }
    18281828        | type_name '.' TYPEDEFname
    1829                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     1829                { $$ = DeclarationNode::newQualifiedType( $1, DeclarationNode::newFromTypedef( $3 ) ); }
    18301830        | typegen_name
    18311831        | '.' typegen_name
    1832                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     1832                { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), $2 ); }
    18331833        | type_name '.' typegen_name
    1834                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     1834                { $$ = DeclarationNode::newQualifiedType( $1, $3 ); }
    18351835        ;
    18361836
     
    18631863                { forall = false; }                                                             // reset
    18641864          '{' field_declaration_list_opt '}' type_parameters_opt
    1865                 { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $7, $5, true )->addQualifiers( $2 ); }
     1865                { $$ = DeclarationNode::newAggregate( $1, nullptr, $7, $5, true )->addQualifiers( $2 ); }
    18661866        | aggregate_key attribute_list_opt no_attr_identifier fred
    18671867                {
     
    18731873        | aggregate_key attribute_list_opt type_name fred
    18741874                {
    1875                         typedefTable.makeTypedef( *$3->type->symbolic.name, forall | typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
     1875                        // for type_name can be a qualified type name S.T, in which case only the last name in the chain needs a typedef (other names in the chain should already have one)
     1876                        typedefTable.makeTypedef( *$3->type->leafName(), forall | typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
    18761877                        forall = false;                                                         // reset
    18771878                }
     
    19361937                { distExt( $3 ); $$ = distAttr( $2, $3 ); }             // mark all fields in list
    19371938        | typedef_declaration ';'                                                       // CFA
    1938                 { SemanticError( yylloc, "Typedef in aggregate is currently unimplemented." ); $$ = nullptr; }
    19391939        | cfa_field_declaring_list ';'                                          // CFA, new style field declaration
    19401940        | EXTENSION cfa_field_declaring_list ';'                        // GCC
    19411941                { distExt( $2 ); $$ = $2; }                                             // mark all fields in list
    19421942        | cfa_typedef_declaration ';'                                           // CFA
    1943                 { SemanticError( yylloc, "Typedef in aggregate is currently unimplemented." ); $$ = nullptr; }
    19441943        | static_assert                                                                         // C11
    19451944        ;
     
    19901989enum_type:                                                                                              // enum
    19911990        ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
    1992                 { $$ = DeclarationNode::newEnum( new string( DeclarationNode::anonymous.newName() ), $4, true )->addQualifiers( $2 ); }
     1991                { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
    19931992        | ENUM attribute_list_opt no_attr_identifier
    19941993                { typedefTable.makeTypedef( *$3 ); }
  • src/SymTab/Indexer.cc

    rfc20514 r777ed2b  
    272272        }
    273273
     274        NamedTypeDecl *Indexer::globalLookupType( const std::string &id ) const {
     275                return lookupTypeAtScope( id, 0 );
     276        }
     277
     278        StructDecl *Indexer::globalLookupStruct( const std::string &id ) const {
     279                return lookupStructAtScope( id, 0 );
     280        }
     281
     282        UnionDecl *Indexer::globalLookupUnion( const std::string &id ) const {
     283                return lookupUnionAtScope( id, 0 );
     284        }
     285
     286        EnumDecl *Indexer::globalLookupEnum( const std::string &id ) const {
     287                return lookupEnumAtScope( id, 0 );
     288        }
     289
    274290        EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
    275291                if ( ! tables ) return 0;
     
    347363                if ( ! tables ) return 0;
    348364                if ( tables->scope < scope ) return 0;
     365                if ( tables->scope > scope ) return tables->base.lookupTypeAtScope( id, scope );
    349366
    350367                TypeTable::const_iterator ret = tables->typeTable.find( id );
     
    355372                if ( ! tables ) return 0;
    356373                if ( tables->scope < scope ) return 0;
     374                if ( tables->scope > scope ) return tables->base.lookupStructAtScope( id, scope );
    357375
    358376                StructTable::const_iterator ret = tables->structTable.find( id );
     
    363381                if ( ! tables ) return 0;
    364382                if ( tables->scope < scope ) return 0;
     383                if ( tables->scope > scope ) return tables->base.lookupEnumAtScope( id, scope );
    365384
    366385                EnumTable::const_iterator ret = tables->enumTable.find( id );
     
    371390                if ( ! tables ) return 0;
    372391                if ( tables->scope < scope ) return 0;
     392                if ( tables->scope > scope ) return tables->base.lookupUnionAtScope( id, scope );
    373393
    374394                UnionTable::const_iterator ret = tables->unionTable.find( id );
     
    379399                if ( ! tables ) return 0;
    380400                if ( tables->scope < scope ) return 0;
     401                if ( tables->scope > scope ) return tables->base.lookupTraitAtScope( id, scope );
    381402
    382403                TraitTable::const_iterator ret = tables->traitTable.find( id );
     
    486507
    487508        bool addedTypeConflicts( NamedTypeDecl *existing, NamedTypeDecl *added ) {
    488                 if ( existing->get_base() == 0 ) {
     509                if ( existing->base == nullptr ) {
    489510                        return false;
    490                 } else if ( added->get_base() == 0 ) {
     511                } else if ( added->base == nullptr ) {
    491512                        return true;
    492513                } else {
    493                         SemanticError( added, "redeclaration of " );
    494                 }
     514                        assert( existing->base && added->base );
     515                        // typedef redeclarations are errors only if types are different
     516                        if ( ! ResolvExpr::typesCompatible( existing->base, added->base, Indexer() ) ) {
     517                                SemanticError( added->location, "redeclaration of " + added->name );
     518                        }
     519                }
     520                // does not need to be added to the table if both existing and added have a base that are the same
     521                return true;
    495522        }
    496523
     
    499526                makeWritable();
    500527
    501                 const std::string &id = decl->get_name();
     528                const std::string &id = decl->name;
    502529                TypeTable::iterator existing = tables->typeTable.find( id );
    503530                if ( existing == tables->typeTable.end() ) {
     
    532559                makeWritable();
    533560
    534                 const std::string &id = decl->get_name();
     561                const std::string &id = decl->name;
    535562                StructTable::iterator existing = tables->structTable.find( id );
    536563                if ( existing == tables->structTable.end() ) {
     
    551578                makeWritable();
    552579
    553                 const std::string &id = decl->get_name();
     580                const std::string &id = decl->name;
    554581                EnumTable::iterator existing = tables->enumTable.find( id );
    555582                if ( existing == tables->enumTable.end() ) {
     
    575602                makeWritable();
    576603
    577                 const std::string &id = decl->get_name();
     604                const std::string &id = decl->name;
    578605                UnionTable::iterator existing = tables->unionTable.find( id );
    579606                if ( existing == tables->unionTable.end() ) {
     
    594621                makeWritable();
    595622
    596                 const std::string &id = decl->get_name();
     623                const std::string &id = decl->name;
    597624                TraitTable::iterator existing = tables->traitTable.find( id );
    598625                if ( existing == tables->traitTable.end() ) {
  • src/SymTab/Indexer.h

    rfc20514 r777ed2b  
    7070                /// Gets the top-most trait declaration with the given ID
    7171                TraitDecl *lookupTrait( const std::string &id ) const;
     72
     73                /// Gets the type declaration with the given ID at global scope
     74                NamedTypeDecl *globalLookupType( const std::string &id ) const;
     75                /// Gets the struct declaration with the given ID at global scope
     76                StructDecl *globalLookupStruct( const std::string &id ) const;
     77                /// Gets the union declaration with the given ID at global scope
     78                UnionDecl *globalLookupUnion( const std::string &id ) const;
     79                /// Gets the enum declaration with the given ID at global scope
     80                EnumDecl *globalLookupEnum( const std::string &id ) const;
    7281
    7382                void print( std::ostream &os, int indent = 0 ) const;
  • src/SymTab/Mangler.cc

    rfc20514 r777ed2b  
    6060                                void postvisit( ZeroType * zeroType );
    6161                                void postvisit( OneType * oneType );
     62                                void postvisit( QualifiedType * qualType );
    6263
    6364                                std::string get_mangleName() { return mangleName.str(); }
     
    171172                                        "w",    // SignedInt128
    172173                                        "Uw",   // UnsignedInt128
    173                                         "x",   // Float80
    174                                         "y",   // Float128
     174                                        "x",    // Float80
     175                                        "y",    // Float128
    175176                                };
    176177                                static_assert(
     
    312313                        void Mangler::postvisit( OneType * ) {
    313314                                mangleName << "O";
     315                        }
     316
     317                        void Mangler::postvisit( QualifiedType * qualType ) {
     318                                maybeAccept( qualType->parent, *visitor );
     319                                mangleName << "__";
     320                                maybeAccept( qualType->child, *visitor );
    314321                        }
    315322
  • src/SymTab/Validate.cc

    rfc20514 r777ed2b  
    7777class SwitchStmt;
    7878
    79 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
     79#define debugPrint( x ) if ( doDebug ) x
    8080
    8181namespace SymTab {
     82        /// hoists declarations that are difficult to hoist while parsing
     83        struct HoistTypeDecls final : public WithDeclsToAdd {
     84                void previsit( SizeofExpr * );
     85                void previsit( AlignofExpr * );
     86                void previsit( UntypedOffsetofExpr * );
     87                void handleType( Type * );
     88        };
     89
     90        struct FixQualifiedTypes final : public WithIndexer {
     91                Type * postmutate( QualifiedType * );
     92        };
     93
    8294        struct HoistStruct final : public WithDeclsToAdd, public WithGuards {
    8395                /// Flattens nested struct types
    8496                static void hoistStruct( std::list< Declaration * > &translationUnit );
    8597
    86                 void previsit( EnumInstType * enumInstType );
    87                 void previsit( StructInstType * structInstType );
    88                 void previsit( UnionInstType * unionInstType );
    8998                void previsit( StructDecl * aggregateDecl );
    9099                void previsit( UnionDecl * aggregateDecl );
    91100                void previsit( StaticAssertDecl * assertDecl );
     101                void previsit( StructInstType * type );
     102                void previsit( UnionInstType * type );
     103                void previsit( EnumInstType * type );
    92104
    93105          private:
     
    112124
    113125        /// Associates forward declarations of aggregates with their definitions
    114         struct LinkReferenceToTypes final : public WithIndexer, public WithGuards {
     126        struct LinkReferenceToTypes final : public WithIndexer, public WithGuards, public WithVisitorRef<LinkReferenceToTypes>, public WithShortCircuiting {
    115127                LinkReferenceToTypes( const Indexer *indexer );
    116128                void postvisit( TypeInstType *typeInst );
     
    120132                void postvisit( UnionInstType *unionInst );
    121133                void postvisit( TraitInstType *traitInst );
     134                void previsit( QualifiedType * qualType );
     135                void postvisit( QualifiedType * qualType );
    122136
    123137                void postvisit( EnumDecl *enumDecl );
     
    165179        };
    166180
    167         struct EliminateTypedef final : public WithVisitorRef<EliminateTypedef>, public WithGuards {
    168                 EliminateTypedef() : scopeLevel( 0 ) {}
     181        struct ReplaceTypedef final : public WithVisitorRef<ReplaceTypedef>, public WithGuards, public WithShortCircuiting, public WithDeclsToAdd {
     182                ReplaceTypedef() : scopeLevel( 0 ) {}
    169183                /// Replaces typedefs by forward declarations
    170                 static void eliminateTypedef( std::list< Declaration * > &translationUnit );
    171 
     184                static void replaceTypedef( std::list< Declaration * > &translationUnit );
     185
     186                void premutate( QualifiedType * );
     187                Type * postmutate( QualifiedType * qualType );
    172188                Type * postmutate( TypeInstType * aggregateUseType );
    173189                Declaration * postmutate( TypedefDecl * typeDecl );
     
    180196
    181197                void premutate( CompoundStmt * compoundStmt );
    182                 CompoundStmt * postmutate( CompoundStmt * compoundStmt );
    183198
    184199                void premutate( StructDecl * structDecl );
    185                 Declaration * postmutate( StructDecl * structDecl );
    186200                void premutate( UnionDecl * unionDecl );
    187                 Declaration * postmutate( UnionDecl * unionDecl );
    188201                void premutate( EnumDecl * enumDecl );
    189                 Declaration * postmutate( EnumDecl * enumDecl );
    190                 Declaration * postmutate( TraitDecl * contextDecl );
     202                void premutate( TraitDecl * );
    191203
    192204                void premutate( FunctionType * ftype );
     
    194206          private:
    195207                template<typename AggDecl>
    196                 AggDecl *handleAggregate( AggDecl * aggDecl );
    197 
    198                 template<typename AggDecl>
    199208                void addImplicitTypedef( AggDecl * aggDecl );
     209                template< typename AggDecl >
     210                void handleAggregate( AggDecl * aggr );
    200211
    201212                typedef std::unique_ptr<TypedefDecl> TypedefDeclPtr;
    202213                typedef ScopedMap< std::string, std::pair< TypedefDeclPtr, int > > TypedefMap;
    203                 typedef std::map< std::string, TypeDecl * > TypeDeclMap;
     214                typedef ScopedMap< std::string, TypeDecl * > TypeDeclMap;
    204215                TypedefMap typedefNames;
    205216                TypeDeclMap typedeclNames;
    206217                int scopeLevel;
    207218                bool inFunctionType = false;
     219        };
     220
     221        struct EliminateTypedef {
     222                /// removes TypedefDecls from the AST
     223                static void eliminateTypedef( std::list< Declaration * > &translationUnit );
     224
     225                template<typename AggDecl>
     226                void handleAggregate( AggDecl *aggregateDecl );
     227
     228                void previsit( StructDecl * aggregateDecl );
     229                void previsit( UnionDecl * aggregateDecl );
     230                void previsit( CompoundStmt * compoundStmt );
    208231        };
    209232
     
    263286                PassVisitor<FindSpecialDeclarations> finder;
    264287                PassVisitor<LabelAddressFixer> labelAddrFixer;
    265 
    266                 EliminateTypedef::eliminateTypedef( translationUnit );
    267                 HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
     288                PassVisitor<HoistTypeDecls> hoistDecls;
     289                PassVisitor<FixQualifiedTypes> fixQual;
     290
     291                acceptAll( translationUnit, hoistDecls );
     292                ReplaceTypedef::replaceTypedef( translationUnit );
    268293                ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
    269294                acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
    270295                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
     296                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes, because aggregate members are accessed
     297                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
     298                EliminateTypedef::eliminateTypedef( translationUnit ); //
    271299                acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
    272300                VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
     
    294322        }
    295323
     324
     325        void HoistTypeDecls::handleType( Type * type ) {
     326                // some type declarations are buried in expressions and not easy to hoist during parsing; hoist them here
     327                AggregateDecl * aggr = nullptr;
     328                if ( StructInstType * inst = dynamic_cast< StructInstType * >( type ) ) {
     329                        aggr = inst->baseStruct;
     330                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( type ) ) {
     331                        aggr = inst->baseUnion;
     332                } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( type ) ) {
     333                        aggr = inst->baseEnum;
     334                }
     335                if ( aggr && aggr->body ) {
     336                        declsToAddBefore.push_front( aggr );
     337                }
     338        }
     339
     340        void HoistTypeDecls::previsit( SizeofExpr * expr ) {
     341                handleType( expr->type );
     342        }
     343
     344        void HoistTypeDecls::previsit( AlignofExpr * expr ) {
     345                handleType( expr->type );
     346        }
     347
     348        void HoistTypeDecls::previsit( UntypedOffsetofExpr * expr ) {
     349                handleType( expr->type );
     350        }
     351
     352
     353        Type * FixQualifiedTypes::postmutate( QualifiedType * qualType ) {
     354                Type * parent = qualType->parent;
     355                Type * child = qualType->child;
     356                if ( dynamic_cast< GlobalScopeType * >( qualType->parent ) ) {
     357                        // .T => lookup T at global scope
     358                        if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
     359                                auto td = indexer.globalLookupType( inst->name );
     360                                if ( ! td ) {
     361                                        SemanticError( qualType->location, toString("Use of undefined global type ", inst->name) );
     362                                }
     363                                auto base = td->base;
     364                                assert( base );
     365                                return base->clone();
     366                        } else {
     367                                // .T => T is not a type name
     368                                assertf( false, "unhandled global qualified child type: %s", toCString(child) );
     369                        }
     370                } else {
     371                        // S.T => S must be an aggregate type, find the declaration for T in S.
     372                        AggregateDecl * aggr = nullptr;
     373                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( parent ) ) {
     374                                aggr = inst->baseStruct;
     375                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * > ( parent ) ) {
     376                                aggr = inst->baseUnion;
     377                        } else {
     378                                SemanticError( qualType->location, toString("Qualified type requires an aggregate on the left, but has: ", parent) );
     379                        }
     380                        assert( aggr ); // TODO: need to handle forward declarations
     381                        for ( Declaration * member : aggr->members ) {
     382                                if ( StructInstType * inst = dynamic_cast< StructInstType * >( child ) ) {
     383                                        if ( StructDecl * aggr = dynamic_cast< StructDecl * >( member ) ) {
     384                                                if ( aggr->name == inst->name ) {
     385                                                        return new StructInstType( qualType->get_qualifiers(), aggr );
     386                                                }
     387                                        }
     388                                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( child ) ) {
     389                                        if ( UnionDecl * aggr = dynamic_cast< UnionDecl * > ( member ) ) {
     390                                                if ( aggr->name == inst->name ) {
     391                                                        return new UnionInstType( qualType->get_qualifiers(), aggr );
     392                                                }
     393                                        }
     394                                } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( child ) ) {
     395                                        if ( EnumDecl * aggr = dynamic_cast< EnumDecl * > ( member ) ) {
     396                                                if ( aggr->name == inst->name ) {
     397                                                        return new EnumInstType( qualType->get_qualifiers(), aggr );
     398                                                }
     399                                        }
     400                                } else if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
     401                                        // struct typedefs are being replaced by forward decls too early; move it to hoist struct
     402                                        if ( NamedTypeDecl * aggr = dynamic_cast< NamedTypeDecl * > ( member ) ) {
     403                                                if ( aggr->name == inst->name ) {
     404                                                        assert( aggr->base );
     405                                                        return aggr->base->clone();
     406                                                }
     407                                        }
     408                                } else {
     409                                        // S.T - S is not an aggregate => error
     410                                        assertf( false, "unhandled qualified child type: %s", toCString(qualType) );
     411                                }
     412                        }
     413                        // failed to find a satisfying definition of type
     414                        SemanticError( qualType->location, toString("Undefined type in qualified type: ", qualType) );
     415                }
     416
     417                // ... may want to link canonical SUE definition to each forward decl so that it becomes easier to lookup?
     418        }
     419
     420
    296421        void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
    297422                PassVisitor<HoistStruct> hoister;
     
    303428        }
    304429
     430        namespace {
     431                void qualifiedName( AggregateDecl * aggr, std::ostringstream & ss ) {
     432                        if ( aggr->parent ) qualifiedName( aggr->parent, ss );
     433                        ss << "__" << aggr->name;
     434                }
     435
     436                // mangle nested type names using entire parent chain
     437                std::string qualifiedName( AggregateDecl * aggr ) {
     438                        std::ostringstream ss;
     439                        qualifiedName( aggr, ss );
     440                        return ss.str();
     441                }
     442        }
     443
    305444        template< typename AggDecl >
    306445        void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
    307446                if ( parentAggr ) {
     447                        aggregateDecl->parent = parentAggr;
     448                        aggregateDecl->name = qualifiedName( aggregateDecl );
    308449                        // Add elements in stack order corresponding to nesting structure.
    309450                        declsToAddBefore.push_front( aggregateDecl );
     
    316457        }
    317458
    318         void HoistStruct::previsit( EnumInstType * inst ) {
    319                 if ( inst->baseEnum && inst->baseEnum->body ) {
    320                         declsToAddBefore.push_front( inst->baseEnum );
    321                 }
    322         }
    323 
    324         void HoistStruct::previsit( StructInstType * inst ) {
    325                 if ( inst->baseStruct && inst->baseStruct->body ) {
    326                         declsToAddBefore.push_front( inst->baseStruct );
    327                 }
    328         }
    329 
    330         void HoistStruct::previsit( UnionInstType * inst ) {
    331                 if ( inst->baseUnion && inst->baseUnion->body ) {
    332                         declsToAddBefore.push_front( inst->baseUnion );
    333                 }
    334         }
    335 
    336459        void HoistStruct::previsit( StaticAssertDecl * assertDecl ) {
    337460                if ( parentAggr ) {
     
    348471        }
    349472
     473        void HoistStruct::previsit( StructInstType * type ) {
     474                // need to reset type name after expanding to qualified name
     475                assert( type->baseStruct );
     476                type->name = type->baseStruct->name;
     477        }
     478
     479        void HoistStruct::previsit( UnionInstType * type ) {
     480                assert( type->baseUnion );
     481                type->name = type->baseUnion->name;
     482        }
     483
     484        void HoistStruct::previsit( EnumInstType * type ) {
     485                assert( type->baseEnum );
     486                type->name = type->baseEnum->name;
     487        }
     488
     489
     490        bool isTypedef( Declaration *decl ) {
     491                return dynamic_cast< TypedefDecl * >( decl );
     492        }
     493
     494        void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
     495                PassVisitor<EliminateTypedef> eliminator;
     496                acceptAll( translationUnit, eliminator );
     497                filter( translationUnit, isTypedef, true );
     498        }
     499
     500        template< typename AggDecl >
     501        void EliminateTypedef::handleAggregate( AggDecl *aggregateDecl ) {
     502                filter( aggregateDecl->members, isTypedef, true );
     503        }
     504
     505        void EliminateTypedef::previsit( StructDecl * aggregateDecl ) {
     506                handleAggregate( aggregateDecl );
     507        }
     508
     509        void EliminateTypedef::previsit( UnionDecl * aggregateDecl ) {
     510                handleAggregate( aggregateDecl );
     511        }
     512
     513        void EliminateTypedef::previsit( CompoundStmt * compoundStmt ) {
     514                // remove and delete decl stmts
     515                filter( compoundStmt->kids, [](Statement * stmt) {
     516                        if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
     517                                if ( dynamic_cast< TypedefDecl * >( declStmt->decl ) ) {
     518                                        return true;
     519                                } // if
     520                        } // if
     521                        return false;
     522                }, true);
     523        }
     524
    350525        void EnumAndPointerDecay::previsit( EnumDecl *enumDecl ) {
    351526                // Set the type of each member of the enumeration to be EnumConstant
    352                 for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
     527                for ( std::list< Declaration * >::iterator i = enumDecl->members.begin(); i != enumDecl->members.end(); ++i ) {
    353528                        ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
    354529                        assert( obj );
    355                         obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) );
     530                        obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->name ) );
    356531                } // for
    357532        }
     
    395570
    396571        void LinkReferenceToTypes::postvisit( EnumInstType *enumInst ) {
    397                 EnumDecl *st = local_indexer->lookupEnum( enumInst->get_name() );
     572                EnumDecl *st = local_indexer->lookupEnum( enumInst->name );
    398573                // it's not a semantic error if the enum is not found, just an implicit forward declaration
    399574                if ( st ) {
    400                         //assert( ! enumInst->get_baseEnum() || enumInst->get_baseEnum()->get_members().empty() || ! st->get_members().empty() );
    401                         enumInst->set_baseEnum( st );
    402                 } // if
    403                 if ( ! st || st->get_members().empty() ) {
     575                        enumInst->baseEnum = st;
     576                } // if
     577                if ( ! st || ! st->body ) {
    404578                        // use of forward declaration
    405                         forwardEnums[ enumInst->get_name() ].push_back( enumInst );
     579                        forwardEnums[ enumInst->name ].push_back( enumInst );
    406580                } // if
    407581        }
     
    416590
    417591        void LinkReferenceToTypes::postvisit( StructInstType *structInst ) {
    418                 StructDecl *st = local_indexer->lookupStruct( structInst->get_name() );
     592                StructDecl *st = local_indexer->lookupStruct( structInst->name );
    419593                // it's not a semantic error if the struct is not found, just an implicit forward declaration
    420594                if ( st ) {
    421                         //assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
    422                         structInst->set_baseStruct( st );
    423                 } // if
    424                 if ( ! st || st->get_members().empty() ) {
     595                        structInst->baseStruct = st;
     596                } // if
     597                if ( ! st || ! st->body ) {
    425598                        // use of forward declaration
    426                         forwardStructs[ structInst->get_name() ].push_back( structInst );
     599                        forwardStructs[ structInst->name ].push_back( structInst );
    427600                } // if
    428601                checkGenericParameters( structInst );
     
    430603
    431604        void LinkReferenceToTypes::postvisit( UnionInstType *unionInst ) {
    432                 UnionDecl *un = local_indexer->lookupUnion( unionInst->get_name() );
     605                UnionDecl *un = local_indexer->lookupUnion( unionInst->name );
    433606                // it's not a semantic error if the union is not found, just an implicit forward declaration
    434607                if ( un ) {
    435                         unionInst->set_baseUnion( un );
    436                 } // if
    437                 if ( ! un || un->get_members().empty() ) {
     608                        unionInst->baseUnion = un;
     609                } // if
     610                if ( ! un || ! un->body ) {
    438611                        // use of forward declaration
    439                         forwardUnions[ unionInst->get_name() ].push_back( unionInst );
     612                        forwardUnions[ unionInst->name ].push_back( unionInst );
    440613                } // if
    441614                checkGenericParameters( unionInst );
     615        }
     616
     617        void LinkReferenceToTypes::previsit( QualifiedType * ) {
     618                visit_children = false;
     619        }
     620
     621        void LinkReferenceToTypes::postvisit( QualifiedType * qualType ) {
     622                // linking only makes sense for the 'oldest ancestor' of the qualified type
     623                qualType->parent->accept( *visitor );
    442624        }
    443625
     
    450632                        DeclarationWithType * dwt2 = dynamic_cast<DeclarationWithType *>( d2 );
    451633                        if ( dwt1 && dwt2 ) {
    452                                 if ( dwt1->get_name() == dwt2->get_name() && ResolvExpr::typesCompatible( dwt1->get_type(), dwt2->get_type(), SymTab::Indexer() ) ) {
     634                                if ( dwt1->name == dwt2->name && ResolvExpr::typesCompatible( dwt1->get_type(), dwt2->get_type(), SymTab::Indexer() ) ) {
    453635                                        // std::cerr << "=========== equal:" << std::endl;
    454636                                        // std::cerr << "d1: " << d1 << std::endl;
     
    475657        template< typename Iterator >
    476658        void expandAssertions( TraitInstType * inst, Iterator out ) {
    477                 assertf( inst->baseTrait, "Trait instance not linked to base trait: %s", toString( inst ).c_str() );
     659                assertf( inst->baseTrait, "Trait instance not linked to base trait: %s", toCString( inst ) );
    478660                std::list< DeclarationWithType * > asserts;
    479661                for ( Declaration * decl : inst->baseTrait->members ) {
     
    512694                        SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
    513695                } // if
    514                 if ( traitDecl->get_parameters().size() != traitInst->get_parameters().size() ) {
     696                if ( traitDecl->parameters.size() != traitInst->parameters.size() ) {
    515697                        SemanticError( traitInst, "incorrect number of trait parameters: " );
    516698                } // if
     
    518700
    519701                // need to carry over the 'sized' status of each decl in the instance
    520                 for ( auto p : group_iterate( traitDecl->get_parameters(), traitInst->get_parameters() ) ) {
     702                for ( auto p : group_iterate( traitDecl->parameters, traitInst->parameters ) ) {
    521703                        TypeExpr * expr = dynamic_cast< TypeExpr * >( std::get<1>(p) );
    522704                        if ( ! expr ) {
     
    525707                        if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
    526708                                TypeDecl * formalDecl = std::get<0>(p);
    527                                 TypeDecl * instDecl = inst->get_baseType();
     709                                TypeDecl * instDecl = inst->baseType;
    528710                                if ( formalDecl->get_sized() ) instDecl->set_sized( true );
    529711                        }
     
    534716        void LinkReferenceToTypes::postvisit( EnumDecl *enumDecl ) {
    535717                // visit enum members first so that the types of self-referencing members are updated properly
    536                 if ( ! enumDecl->get_members().empty() ) {
    537                         ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->get_name() );
     718                if ( enumDecl->body ) {
     719                        ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->name );
    538720                        if ( fwds != forwardEnums.end() ) {
    539721                                for ( std::list< EnumInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
    540                                         (*inst )->set_baseEnum( enumDecl );
     722                                        (*inst)->baseEnum = enumDecl;
    541723                                } // for
    542724                                forwardEnums.erase( fwds );
     
    574756                // visit struct members first so that the types of self-referencing members are updated properly
    575757                // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and their defaults)
    576                 if ( ! structDecl->get_members().empty() ) {
    577                         ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
     758                if ( structDecl->body ) {
     759                        ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->name );
    578760                        if ( fwds != forwardStructs.end() ) {
    579761                                for ( std::list< StructInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
    580                                         (*inst )->set_baseStruct( structDecl );
     762                                        (*inst)->baseStruct = structDecl;
    581763                                } // for
    582764                                forwardStructs.erase( fwds );
     
    586768
    587769        void LinkReferenceToTypes::postvisit( UnionDecl *unionDecl ) {
    588                 if ( ! unionDecl->get_members().empty() ) {
    589                         ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
     770                if ( unionDecl->body ) {
     771                        ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->name );
    590772                        if ( fwds != forwardUnions.end() ) {
    591773                                for ( std::list< UnionInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
    592                                         (*inst )->set_baseUnion( unionDecl );
     774                                        (*inst)->baseUnion = unionDecl;
    593775                                } // for
    594776                                forwardUnions.erase( fwds );
     
    600782                // ensure generic parameter instances are renamed like the base type
    601783                if ( inGeneric && typeInst->baseType ) typeInst->name = typeInst->baseType->name;
    602                 if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->get_name() ) ) {
     784                if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->name ) ) {
    603785                        if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
    604786                                typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );
     
    679861
    680862
    681         bool isTypedef( Declaration *decl ) {
    682                 return dynamic_cast< TypedefDecl * >( decl );
    683         }
    684 
    685         void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
    686                 PassVisitor<EliminateTypedef> eliminator;
     863        void ReplaceTypedef::replaceTypedef( std::list< Declaration * > &translationUnit ) {
     864                PassVisitor<ReplaceTypedef> eliminator;
    687865                mutateAll( translationUnit, eliminator );
    688866                if ( eliminator.pass.typedefNames.count( "size_t" ) ) {
    689867                        // grab and remember declaration of size_t
    690                         SizeType = eliminator.pass.typedefNames["size_t"].first->get_base()->clone();
     868                        SizeType = eliminator.pass.typedefNames["size_t"].first->base->clone();
    691869                } else {
    692870                        // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
     
    694872                        SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
    695873                }
    696                 filter( translationUnit, isTypedef, true );
    697         }
    698 
    699         Type * EliminateTypedef::postmutate( TypeInstType * typeInst ) {
     874        }
     875
     876        void ReplaceTypedef::premutate( QualifiedType * ) {
     877                visit_children = false;
     878        }
     879
     880        Type * ReplaceTypedef::postmutate( QualifiedType * qualType ) {
     881                // replacing typedefs only makes sense for the 'oldest ancestor' of the qualified type
     882                qualType->parent = qualType->parent->acceptMutator( *visitor );
     883                return qualType;
     884        }
     885
     886        Type * ReplaceTypedef::postmutate( TypeInstType * typeInst ) {
    700887                // instances of typedef types will come here. If it is an instance
    701888                // of a typdef type, link the instance to its actual type.
    702                 TypedefMap::const_iterator def = typedefNames.find( typeInst->get_name() );
     889                TypedefMap::const_iterator def = typedefNames.find( typeInst->name );
    703890                if ( def != typedefNames.end() ) {
    704891                        Type *ret = def->second.first->base->clone();
     892                        ret->location = typeInst->location;
    705893                        ret->get_qualifiers() |= typeInst->get_qualifiers();
    706894                        // attributes are not carried over from typedef to function parameters/return values
     
    717905                                        SemanticError( typeInst->location, "Cannot apply type parameters to base type of " + typeInst->name );
    718906                                }
    719                                 rtt->get_parameters().clear();
     907                                rtt->parameters.clear();
    720908                                cloneAll( typeInst->parameters, rtt->parameters );
    721909                                mutateAll( rtt->parameters, *visitor );  // recursively fix typedefs on parameters
     
    724912                        return ret;
    725913                } else {
    726                         TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->get_name() );
    727                         assertf( base != typedeclNames.end(), "Cannot find typedecl name %s", typeInst->name.c_str() );
     914                        TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->name );
     915                        if ( base == typedeclNames.end() ) {
     916                                SemanticError( typeInst->location, toString("Use of undefined type ", typeInst->name) );
     917                        }
    728918                        typeInst->set_baseType( base->second );
    729                 } // if
    730                 return typeInst;
     919                        return typeInst;
     920                } // if
     921                assert( false );
    731922        }
    732923
     
    745936        }
    746937
    747         Declaration *EliminateTypedef::postmutate( TypedefDecl * tyDecl ) {
    748                 if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
     938        Declaration * ReplaceTypedef::postmutate( TypedefDecl * tyDecl ) {
     939                if ( typedefNames.count( tyDecl->name ) == 1 && typedefNames[ tyDecl->name ].second == scopeLevel ) {
    749940                        // typedef to the same name from the same scope
    750941                        // must be from the same type
    751942
    752                         Type * t1 = tyDecl->get_base();
    753                         Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
     943                        Type * t1 = tyDecl->base;
     944                        Type * t2 = typedefNames[ tyDecl->name ].first->base;
    754945                        if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) {
    755946                                SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
     
    763954                        }
    764955                } else {
    765                         typedefNames[ tyDecl->get_name() ] = std::make_pair( TypedefDeclPtr( tyDecl ), scopeLevel );
     956                        typedefNames[ tyDecl->name ] = std::make_pair( TypedefDeclPtr( tyDecl ), scopeLevel );
    766957                } // if
    767958
     
    775966                // Note, qualifiers on the typedef are superfluous for the forward declaration.
    776967
    777                 Type *designatorType = tyDecl->get_base()->stripDeclarator();
     968                Type *designatorType = tyDecl->base->stripDeclarator();
    778969                if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( designatorType ) ) {
    779                         return new StructDecl( aggDecl->get_name(), DeclarationNode::Struct, noAttributes, tyDecl->get_linkage() );
     970                        declsToAddBefore.push_back( new StructDecl( aggDecl->name, DeclarationNode::Struct, noAttributes, tyDecl->linkage ) );
    780971                } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
    781                         return new UnionDecl( aggDecl->get_name(), noAttributes, tyDecl->get_linkage() );
     972                        declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) );
    782973                } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) {
    783                         return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() );
    784                 } else {
    785                         return tyDecl->clone();
    786                 } // if
    787         }
    788 
    789         void EliminateTypedef::premutate( TypeDecl * typeDecl ) {
    790                 TypedefMap::iterator i = typedefNames.find( typeDecl->get_name() );
     974                        declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage ) );
     975                } // if
     976                return tyDecl->clone();
     977        }
     978
     979        void ReplaceTypedef::premutate( TypeDecl * typeDecl ) {
     980                TypedefMap::iterator i = typedefNames.find( typeDecl->name );
    791981                if ( i != typedefNames.end() ) {
    792982                        typedefNames.erase( i ) ;
    793983                } // if
    794984
    795                 typedeclNames[ typeDecl->get_name() ] = typeDecl;
    796         }
    797 
    798         void EliminateTypedef::premutate( FunctionDecl * ) {
     985                typedeclNames.insert( typeDecl->name, typeDecl );
     986        }
     987
     988        void ReplaceTypedef::premutate( FunctionDecl * ) {
    799989                GuardScope( typedefNames );
    800         }
    801 
    802         void EliminateTypedef::premutate( ObjectDecl * ) {
     990                GuardScope( typedeclNames );
     991        }
     992
     993        void ReplaceTypedef::premutate( ObjectDecl * ) {
    803994                GuardScope( typedefNames );
    804         }
    805 
    806         DeclarationWithType *EliminateTypedef::postmutate( ObjectDecl * objDecl ) {
    807                 if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->get_type() ) ) { // function type?
     995                GuardScope( typedeclNames );
     996        }
     997
     998        DeclarationWithType * ReplaceTypedef::postmutate( ObjectDecl * objDecl ) {
     999                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->type ) ) { // function type?
    8081000                        // replace the current object declaration with a function declaration
    809                         FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() );
    810                         objDecl->get_attributes().clear();
     1001                        FunctionDecl * newDecl = new FunctionDecl( objDecl->name, objDecl->get_storageClasses(), objDecl->linkage, funtype, 0, objDecl->attributes, objDecl->get_funcSpec() );
     1002                        objDecl->attributes.clear();
    8111003                        objDecl->set_type( nullptr );
    8121004                        delete objDecl;
     
    8161008        }
    8171009
    818         void EliminateTypedef::premutate( CastExpr * ) {
     1010        void ReplaceTypedef::premutate( CastExpr * ) {
    8191011                GuardScope( typedefNames );
    820         }
    821 
    822         void EliminateTypedef::premutate( CompoundStmt * ) {
     1012                GuardScope( typedeclNames );
     1013        }
     1014
     1015        void ReplaceTypedef::premutate( CompoundStmt * ) {
    8231016                GuardScope( typedefNames );
     1017                GuardScope( typedeclNames );
    8241018                scopeLevel += 1;
    8251019                GuardAction( [this](){ scopeLevel -= 1; } );
    8261020        }
    8271021
    828         CompoundStmt *EliminateTypedef::postmutate( CompoundStmt * compoundStmt ) {
    829                 // remove and delete decl stmts
    830                 filter( compoundStmt->kids, [](Statement * stmt) {
    831                         if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
    832                                 if ( dynamic_cast< TypedefDecl * >( declStmt->get_decl() ) ) {
    833                                         return true;
    834                                 } // if
    835                         } // if
    836                         return false;
    837                 }, true);
    838                 return compoundStmt;
    839         }
    840 
    841         // there may be typedefs nested within aggregates. in order for everything to work properly, these should be removed
    842         // as well
    8431022        template<typename AggDecl>
    844         AggDecl *EliminateTypedef::handleAggregate( AggDecl * aggDecl ) {
    845                 filter( aggDecl->members, isTypedef, true );
    846                 return aggDecl;
    847         }
    848 
    849         template<typename AggDecl>
    850         void EliminateTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
     1023        void ReplaceTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
    8511024                if ( typedefNames.count( aggDecl->get_name() ) == 0 ) {
    8521025                        Type *type = nullptr;
     
    8601033                        TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), aggDecl->location, Type::StorageClasses(), type, aggDecl->get_linkage() ) );
    8611034                        typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel );
    862                 } // if
    863         }
    864 
    865         void EliminateTypedef::premutate( StructDecl * structDecl ) {
     1035                        // add the implicit typedef to the AST
     1036                        declsToAddBefore.push_back( new TypedefDecl( aggDecl->get_name(), aggDecl->location, Type::StorageClasses(), type->clone(), aggDecl->get_linkage() ) );
     1037                } // if
     1038        }
     1039
     1040        template< typename AggDecl >
     1041        void ReplaceTypedef::handleAggregate( AggDecl * aggr ) {
     1042                SemanticErrorException errors;
     1043
     1044                ValueGuard< std::list<Declaration * > > oldBeforeDecls( declsToAddBefore );
     1045                ValueGuard< std::list<Declaration * > > oldAfterDecls ( declsToAddAfter  );
     1046                declsToAddBefore.clear();
     1047                declsToAddAfter.clear();
     1048
     1049                GuardScope( typedefNames );
     1050                GuardScope( typedeclNames );
     1051                mutateAll( aggr->parameters, *visitor );
     1052
     1053                // unroll mutateAll for aggr->members so that implicit typedefs for nested types are added to the aggregate body.
     1054                for ( std::list< Declaration * >::iterator i = aggr->members.begin(); i != aggr->members.end(); ++i ) {
     1055                        if ( !declsToAddAfter.empty() ) { aggr->members.splice( i, declsToAddAfter ); }
     1056
     1057                        try {
     1058                                *i = maybeMutate( *i, *visitor );
     1059                        } catch ( SemanticErrorException &e ) {
     1060                                errors.append( e );
     1061                        }
     1062
     1063                        if ( !declsToAddBefore.empty() ) { aggr->members.splice( i, declsToAddBefore ); }
     1064                }
     1065
     1066                if ( !declsToAddAfter.empty() ) { aggr->members.splice( aggr->members.end(), declsToAddAfter ); }
     1067                if ( !errors.isEmpty() ) { throw errors; }
     1068        }
     1069
     1070        void ReplaceTypedef::premutate( StructDecl * structDecl ) {
     1071                visit_children = false;
    8661072                addImplicitTypedef( structDecl );
    867         }
    868 
    869 
    870         Declaration *EliminateTypedef::postmutate( StructDecl * structDecl ) {
    871                 return handleAggregate( structDecl );
    872         }
    873 
    874         void EliminateTypedef::premutate( UnionDecl * unionDecl ) {
     1073                handleAggregate( structDecl );
     1074        }
     1075
     1076        void ReplaceTypedef::premutate( UnionDecl * unionDecl ) {
     1077                visit_children = false;
    8751078                addImplicitTypedef( unionDecl );
    876         }
    877 
    878         Declaration *EliminateTypedef::postmutate( UnionDecl * unionDecl ) {
    879                 return handleAggregate( unionDecl );
    880         }
    881 
    882         void EliminateTypedef::premutate( EnumDecl * enumDecl ) {
     1079                handleAggregate( unionDecl );
     1080        }
     1081
     1082        void ReplaceTypedef::premutate( EnumDecl * enumDecl ) {
    8831083                addImplicitTypedef( enumDecl );
    8841084        }
    8851085
    886         Declaration *EliminateTypedef::postmutate( EnumDecl * enumDecl ) {
    887                 return handleAggregate( enumDecl );
    888         }
    889 
    890         Declaration *EliminateTypedef::postmutate( TraitDecl * traitDecl ) {
    891                 return handleAggregate( traitDecl );
    892         }
    893 
    894         void EliminateTypedef::premutate( FunctionType * ) {
     1086        void ReplaceTypedef::premutate( FunctionType * ) {
    8951087                GuardValue( inFunctionType );
    8961088                inFunctionType = true;
     1089        }
     1090
     1091        void ReplaceTypedef::premutate( TraitDecl * ) {
     1092                GuardScope( typedefNames );
     1093                GuardScope( typedeclNames);
    8971094        }
    8981095
     
    10241221
    10251222        void ArrayLength::previsit( ObjectDecl * objDecl ) {
    1026                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
     1223                if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->type ) ) {
    10271224                        if ( at->get_dimension() ) return;
    1028                         if ( ListInit * init = dynamic_cast< ListInit * >( objDecl->get_init() ) ) {
    1029                                 at->set_dimension( new ConstantExpr( Constant::from_ulong( init->get_initializers().size() ) ) );
     1225                        if ( ListInit * init = dynamic_cast< ListInit * >( objDecl->init ) ) {
     1226                                at->set_dimension( new ConstantExpr( Constant::from_ulong( init->initializers.size() ) ) );
    10301227                        }
    10311228                }
  • src/SynTree/Declaration.h

    rfc20514 r777ed2b  
    266266        bool body;
    267267        std::list< Attribute * > attributes;
     268        AggregateDecl * parent = nullptr;
    268269
    269270        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
  • src/SynTree/Mutator.h

    rfc20514 r777ed2b  
    101101        virtual Type * mutate( ArrayType * arrayType ) = 0;
    102102        virtual Type * mutate( ReferenceType * refType ) = 0;
     103        virtual Type * mutate( QualifiedType * qualType ) = 0;
    103104        virtual Type * mutate( FunctionType * functionType ) = 0;
    104105        virtual Type * mutate( StructInstType * aggregateUseType ) = 0;
     
    113114        virtual Type * mutate( ZeroType * zeroType ) = 0;
    114115        virtual Type * mutate( OneType * oneType ) = 0;
     116        virtual Type * mutate( GlobalScopeType * globalType ) = 0;
    115117
    116118        virtual Designation * mutate( Designation * designation ) = 0 ;
  • src/SynTree/ReferenceToType.cc

    rfc20514 r777ed2b  
    7676bool StructInstType::isComplete() const { return baseStruct ? baseStruct->has_body() : false; }
    7777
    78 AggregateDecl * StructInstType::getAggr() { return baseStruct; }
     78AggregateDecl * StructInstType::getAggr() const { return baseStruct; }
    7979
    8080TypeSubstitution StructInstType::genericSubstitution() const {
     
    119119bool UnionInstType::isComplete() const { return baseUnion ? baseUnion->has_body() : false; }
    120120
    121 AggregateDecl * UnionInstType::getAggr() { return baseUnion; }
     121AggregateDecl * UnionInstType::getAggr() const { return baseUnion; }
    122122
    123123TypeSubstitution UnionInstType::genericSubstitution() const {
     
    152152bool EnumInstType::isComplete() const { return baseEnum ? baseEnum->has_body() : false; }
    153153
     154AggregateDecl * EnumInstType::getAggr() const { return baseEnum; }
     155
    154156void EnumInstType::print( std::ostream &os, Indenter indent ) const {
    155157        using std::endl;
  • src/SynTree/SynTree.h

    rfc20514 r777ed2b  
    110110class ArrayType;
    111111class ReferenceType;
     112class QualifiedType;
    112113class FunctionType;
    113114class ReferenceToType;
     
    123124class ZeroType;
    124125class OneType;
     126class GlobalScopeType;
    125127
    126128class Designation;
  • src/SynTree/Type.cc

    rfc20514 r777ed2b  
    105105}
    106106
     107
     108QualifiedType::QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child ) : Type( tq, {} ), parent( parent ), child( child ) {
     109}
     110
     111QualifiedType::QualifiedType( const QualifiedType & other ) : Type( other ), parent( maybeClone( other.parent ) ), child( maybeClone( other.child ) ) {
     112}
     113
     114QualifiedType::~QualifiedType() {
     115        delete parent;
     116        delete child;
     117}
     118
     119void QualifiedType::print( std::ostream & os, Indenter indent ) const {
     120        os << "Qualified Type: " << endl;
     121        os << indent+1;
     122        parent->print( os, indent+1 );
     123        os << endl << indent+1;
     124        child->print( os, indent+1 );
     125        os << endl;
     126        Type::print( os, indent+1 );
     127}
     128
     129GlobalScopeType::GlobalScopeType() : Type( Type::Qualifiers(), {} ) {}
     130
     131void GlobalScopeType::print( std::ostream & os, Indenter ) const {
     132        os << "Global Scope Type" << endl;
     133}
     134
     135
    107136// Empty Variable declarations:
    108137const Type::FuncSpecifiers noFuncSpecifiers;
  • src/SynTree/Type.h

    rfc20514 r777ed2b  
    178178        virtual bool isComplete() const { return true; }
    179179
    180         virtual AggregateDecl * getAggr() { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
     180        virtual AggregateDecl * getAggr() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
    181181
    182182        virtual TypeSubstitution genericSubstitution() const;
     
    315315};
    316316
     317class QualifiedType : public Type {
     318public:
     319        Type * parent;
     320        Type * child;
     321
     322        QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child );
     323        QualifiedType( const QualifiedType & tq );
     324        virtual ~QualifiedType();
     325
     326        virtual QualifiedType *clone() const override { return new QualifiedType( *this ); }
     327        virtual void accept( Visitor & v ) override { v.visit( this ); }
     328        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     329        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     330};
     331
    317332class ReferenceType : public Type {
    318333public:
     
    416431        virtual bool isComplete() const override;
    417432
    418         virtual AggregateDecl * getAggr() override;
     433        virtual AggregateDecl * getAggr() const override;
    419434
    420435        virtual TypeSubstitution genericSubstitution() const override;
     
    453468        virtual bool isComplete() const override;
    454469
    455         virtual AggregateDecl * getAggr() override;
     470        virtual AggregateDecl * getAggr() const override;
    456471
    457472        virtual TypeSubstitution genericSubstitution() const override;
     
    485500
    486501        virtual bool isComplete() const override;
     502
     503        virtual AggregateDecl * getAggr() const override;
    487504
    488505        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
     
    665682};
    666683
     684class GlobalScopeType : public Type {
     685  public:
     686        GlobalScopeType();
     687
     688        virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
     689        virtual void accept( Visitor & v ) override { v.visit( this ); }
     690        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     691        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     692};
     693
    667694// Local Variables: //
    668695// tab-width: 4 //
  • src/SynTree/Visitor.h

    rfc20514 r777ed2b  
    103103        virtual void visit( ArrayType * arrayType ) = 0;
    104104        virtual void visit( ReferenceType * refType ) = 0;
     105        virtual void visit( QualifiedType * qualType ) = 0;
    105106        virtual void visit( FunctionType * functionType ) = 0;
    106107        virtual void visit( StructInstType * aggregateUseType ) = 0;
     
    115116        virtual void visit( ZeroType * zeroType ) = 0;
    116117        virtual void visit( OneType * oneType ) = 0;
     118        virtual void visit( GlobalScopeType * globalType ) = 0;
    117119
    118120        virtual void visit( Designation * designation ) = 0;
  • src/main.cc

    rfc20514 r777ed2b  
    247247                } // if
    248248
     249                // Temporary: fill locations after parsing so that every node has a location, for early error messages.
     250                // Eventually we should pass the locations from the parser to every node, but this quick and dirty solution
     251                // works okay for now.
     252                CodeTools::fillLocations( translationUnit );
     253
    249254                // add the assignment statement after the initialization of a type parameter
    250255                PASS( "validate", SymTab::validate( translationUnit, symtabp ) );
  • src/prelude/prelude.old.cf

    rfc20514 r777ed2b  
    728728forall( dtype DT ) void ?{}(       volatile  DT *          &,                   DT * );
    729729forall( dtype DT ) void ?{}(       volatile  DT *          &,       volatile    DT * );
    730 
    731730forall( dtype DT ) void ?{}( const volatile  DT *          &,                   DT * );
    732731forall( dtype DT ) void ?{}( const volatile  DT *          &, const             DT * );
  • src/tests/.expect/attributes.x86.txt

    rfc20514 r777ed2b  
     1signed int __la__Fi___1(){
     2    __attribute__ ((unused)) signed int ___retval_la__i_1;
     3    L: __attribute__ ((unused)) ((void)1);
     4}
     5struct __attribute__ ((unused)) __anonymous0 {
     6};
     7static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     8static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     9static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     10static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     11static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     12}
     13static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     14}
     15static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     16}
     17static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     18    struct __anonymous0 ___ret__13s__anonymous0_1;
     19    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__anonymous0_1)));
     20    return ___ret__13s__anonymous0_1;
     21}
     22struct __attribute__ ((unused)) Agn1;
     23struct __attribute__ ((unused)) Agn2 {
     24};
     25static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
     26static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
     27static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
     28static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
     29static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
     30}
     31static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     32}
     33static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
     34}
     35static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     36    struct Agn2 ___ret__5sAgn2_1;
     37    ((void)___constructor__F_5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__5sAgn2_1)));
     38    return ___ret__5sAgn2_1;
     39}
     40enum __attribute__ ((unused)) __anonymous1 {
     41    __E1__C13e__anonymous1_1,
     42};
     43enum __attribute__ ((unused)) Agn3;
     44enum __attribute__ ((packed)) Agn3 {
     45    __E2__C5eAgn3_1,
     46};
     47struct __attribute__ ((unused)) __anonymous2 {
     48};
     49static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     50static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     51static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     52static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     53static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     54}
     55static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     56}
     57static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     58}
     59static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     60    struct __anonymous2 ___ret__13s__anonymous2_1;
     61    ((void)___constructor__F_13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__13s__anonymous2_1)));
     62    return ___ret__13s__anonymous2_1;
     63}
     64struct __attribute__ ((unused)) Agn4 {
     65};
     66static inline void ___constructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1);
     67static inline void ___constructor__F_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1);
     68static inline void ___destructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1);
     69static inline struct Agn4 ___operator_assign__F5sAgn4_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1);
     70static inline void ___constructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1){
     71}
     72static inline void ___constructor__F_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1){
     73}
     74static inline void ___destructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1){
     75}
     76static inline struct Agn4 ___operator_assign__F5sAgn4_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1){
     77    struct Agn4 ___ret__5sAgn4_1;
     78    ((void)___constructor__F_5sAgn45sAgn4_autogen___1((&___ret__5sAgn4_1), (*___dst__5sAgn4_1)));
     79    return ___ret__5sAgn4_1;
     80}
     81struct Fdl {
     82    __attribute__ ((unused)) signed int __f1__i_1;
     83    __attribute__ ((unused)) signed int __f2__i_1;
     84    __attribute__ ((unused,unused)) signed int __f3__i_1;
     85    __attribute__ ((unused)) signed int __f4__i_1;
     86    __attribute__ ((unused,unused)) signed int __f5__i_1;
     87    __attribute__ ((used,packed)) signed int __f6__i_1;
     88    __attribute__ ((used,unused,unused)) signed int __f7__i_1;
     89    __attribute__ ((used,used,unused)) signed int __f8__i_1;
     90    __attribute__ ((unused)) signed int __anonymous_object0;
     91    __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
     92};
     93static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
     94static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
     95static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
     96static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
     97static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1);
     98static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
     99static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
     100static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
     101static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
     102static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
     103static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
     104static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
     105static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object1);
     106static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object2, __attribute__ ((unused,unused)) signed int *__f9__Pi_1);
     107static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
     108    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ?{} */);
     109    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
     110    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     111    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     112    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     113    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     114    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     115    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     116    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     117    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     118}
     119static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
     120    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
     121    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
     122    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
     123    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
     124    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
     125    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1) /* ?{} */);
     126    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
     127    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
     128    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
     129    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
     130}
     131static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
     132    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ^?{} */);
     133    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ^?{} */);
     134    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ^?{} */);
     135    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ^?{} */);
     136    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ^?{} */);
     137    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ^?{} */);
     138    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ^?{} */);
     139    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ^?{} */);
     140    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ^?{} */);
     141    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ^?{} */);
     142}
     143static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
     144    struct Fdl ___ret__4sFdl_1;
     145    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
     146    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
     147    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
     148    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
     149    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
     150    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
     151    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
     152    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
     153    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
     154    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     155    ((void)___constructor__F_4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__4sFdl_1)));
     156    return ___ret__4sFdl_1;
     157}
     158static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
     159    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     160    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
     161    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     162    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     163    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     164    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     165    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     166    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     167    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     168    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     169}
     170static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1){
     171    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     172    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     173    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     174    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     175    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     176    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     177    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     178    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     179    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     180    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     181}
     182static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1){
     183    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     184    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     185    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     186    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     187    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     188    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     189    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     190    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     191    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     192    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     193}
     194static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1){
     195    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     196    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     197    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     198    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     199    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     200    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     201    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     202    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     203    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     204    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     205}
     206static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1){
     207    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     208    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     209    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     210    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     211    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     212    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     213    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     214    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     215    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     216    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     217}
     218static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1){
     219    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     220    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     221    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     222    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     223    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     224    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     225    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     226    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     227    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     228    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     229}
     230static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1){
     231    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     232    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     233    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     234    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     235    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     236    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     237    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     238    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     239    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     240    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     241}
     242static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1){
     243    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     244    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     245    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     246    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     247    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     248    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     249    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     250    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     251    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     252    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     253}
     254static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object3){
     255    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     256    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     257    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     258    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     259    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     260    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     261    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     262    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     263    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
     264    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     265}
     266static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object4, __attribute__ ((unused,unused)) signed int *__f9__Pi_1){
     267    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     268    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     269    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     270    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     271    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     272    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     273    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     274    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     275    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
     276    ((void)((*___dst__4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
     277}
     278__attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
     279__attribute__ ((used,used)) const signed int __vd1__Ci_1;
     280__attribute__ ((used,unused)) const signed int __vd2__Ci_1;
     281__attribute__ ((used,used,used,used)) const signed int *__vd3__PCi_1;
     282__attribute__ ((used,used,unused,used,unused)) const signed int *__vd4__PCi_1;
     283__attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned int )5)];
     284__attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned int )5)];
     285__attribute__ ((used,used,used,used)) const signed int (*__vd7__Fi___1)();
     286__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__Fi___1)();
     287__attribute__ ((unused,used)) signed int __f1__Fi___1();
     288__attribute__ ((unused)) signed int __f1__Fi___1(){
     289    __attribute__ ((unused)) signed int ___retval_f1__i_1;
     290}
     291__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FPPi___1();
     292__attribute__ ((unused,unused,unused)) signed int **const __f2__FPPi___1(){
     293    __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
     294}
     295__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object5))[];
     296__attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
     297    __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
     298}
     299__attribute__ ((unused,used,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object6);
     300__attribute__ ((unused,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object7){
     301    __attribute__ ((unused)) signed int (*___retval_f4__Fi_i__1)(signed int __anonymous_object8);
     302}
     303signed int __vtr__Fi___1(){
     304    __attribute__ ((unused)) signed int ___retval_vtr__i_1;
     305    __attribute__ ((unused,unused,used)) signed int __t1__i_2;
     306    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t2__PPi_2;
     307    __attribute__ ((unused,unused,unused)) signed int __t3__A0i_2[((unsigned int )5)];
     308    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t4__A0PPi_2[((unsigned int )5)];
     309    __attribute__ ((unused,unused,unused)) signed int __t5__Fi___2();
     310    __attribute__ ((unused,unused,unused,unused)) signed int *__t6__FPi___2();
     311}
     312signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1);
     313signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1){
     314    __attribute__ ((unused)) signed int ___retval_ipd1__i_1;
     315}
     316signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     317signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     318    __attribute__ ((unused)) signed int ___retval_ipd2__i_1;
     319}
     320signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     321signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     322    __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
     323}
     324signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)());
     325signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)()){
     326    __attribute__ ((unused)) signed int ___retval_ipd4__i_1;
     327}
     328signed int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) signed int __Foo__i_1);
     329signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
     330signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
     331signed int __tpr4__Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned int )5)]));
     332signed int __tpr5__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
     333signed int __tpr6__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
     334signed int __tpr7__Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
     335signed int __ad__Fi___1(){
     336    __attribute__ ((unused)) signed int ___retval_ad__i_1;
     337    __attribute__ ((used,unused)) signed int __ad1__i_2;
     338    __attribute__ ((unused,unused,unused)) signed int *__ad2__Pi_2;
     339    __attribute__ ((unused,unused,unused)) signed int __ad3__A0i_2[((unsigned int )5)];
     340    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*__ad4__PA0i_2)[((unsigned int )10)];
     341    __attribute__ ((unused,unused,unused,unused,used)) signed int __ad5__i_2;
     342    __attribute__ ((unused,unused,unused,unused,unused)) signed int __ad6__Fi___2();
     343    ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
     344    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
     345    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [5]));
     346    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[10]));
     347    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
     348    struct __attribute__ ((unused)) __anonymous3 {
     349        signed int __i__i_2;
     350    };
     351    inline void ___constructor__F_13s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2){
     352        ((void)((*___dst__13s__anonymous3_2).__i__i_2) /* ?{} */);
     353    }
     354    inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, struct __anonymous3 ___src__13s__anonymous3_2){
     355        ((void)((*___dst__13s__anonymous3_2).__i__i_2=___src__13s__anonymous3_2.__i__i_2) /* ?{} */);
     356    }
     357    inline void ___destructor__F_13s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2){
     358        ((void)((*___dst__13s__anonymous3_2).__i__i_2) /* ^?{} */);
     359    }
     360    inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, struct __anonymous3 ___src__13s__anonymous3_2){
     361        struct __anonymous3 ___ret__13s__anonymous3_2;
     362        ((void)((*___dst__13s__anonymous3_2).__i__i_2=___src__13s__anonymous3_2.__i__i_2));
     363        ((void)___constructor__F_13s__anonymous313s__anonymous3_autogen___2((&___ret__13s__anonymous3_2), (*___dst__13s__anonymous3_2)));
     364        return ___ret__13s__anonymous3_2;
     365    }
     366    inline void ___constructor__F_13s__anonymous3i_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, signed int __i__i_2){
     367        ((void)((*___dst__13s__anonymous3_2).__i__i_2=__i__i_2) /* ?{} */);
     368    }
     369    ((void)sizeof(struct __anonymous3 ));
     370    enum __attribute__ ((unused)) __anonymous4 {
     371        __R__C13e__anonymous4_2,
     372    };
     373    inline void ___constructor__F_13e__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *___dst__13e__anonymous4_2){
     374    }
     375    inline void ___constructor__F_13e__anonymous413e__anonymous4_intrinsic___2(enum __anonymous4 *___dst__13e__anonymous4_2, enum __anonymous4 ___src__13e__anonymous4_2){
     376        ((void)((*___dst__13e__anonymous4_2)=___src__13e__anonymous4_2) /* ?{} */);
     377    }
     378    inline void ___destructor__F_13e__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *___dst__13e__anonymous4_2){
     379    }
     380    inline enum __anonymous4 ___operator_assign__F13e__anonymous4_13e__anonymous413e__anonymous4_intrinsic___2(enum __anonymous4 *___dst__13e__anonymous4_2, enum __anonymous4 ___src__13e__anonymous4_2){
     381        enum __anonymous4 ___ret__13e__anonymous4_2;
     382        ((void)((*___dst__13e__anonymous4_2)=___src__13e__anonymous4_2));
     383        ((void)(___ret__13e__anonymous4_2=(*___dst__13e__anonymous4_2)) /* ?{} */);
     384        return ___ret__13e__anonymous4_2;
     385    }
     386    ((void)sizeof(enum __anonymous4 ));
     387}
     388signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
     389signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object16, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object17);
     390signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object18, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object19);
     391signed int __apd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
     392signed int __apd5__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
     393signed int __apd6__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
     394signed int __apd7__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
     395struct Vad {
     396    __attribute__ ((unused)) signed int __anonymous_object32;
     397    __attribute__ ((unused,unused)) signed int *__anonymous_object33;
     398    __attribute__ ((unused,unused)) signed int __anonymous_object34[((unsigned int )10)];
     399    __attribute__ ((unused,unused)) signed int (*__anonymous_object35)();
     400};
     401static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
     402static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
     403static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
     404static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
     405static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object36);
     406static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object37, __attribute__ ((unused,unused)) signed int *__anonymous_object38);
     407static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object39, __attribute__ ((unused,unused)) signed int *__anonymous_object40, __attribute__ ((unused,unused)) signed int __anonymous_object41[((unsigned int )10)]);
     408static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object42, __attribute__ ((unused,unused)) signed int *__anonymous_object43, __attribute__ ((unused,unused)) signed int __anonymous_object44[((unsigned int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object45)());
     409static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
     410    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ?{} */);
     411    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
     412    {
     413        signed int _index0 = 0;
     414        for (;(_index0<10);((void)(++_index0))) {
     415            ((void)((*___dst__4sVad_1).__anonymous_object34[_index0]) /* ?{} */);
     416        }
     417
     418    }
     419
     420    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     421}
     422static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
     423    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
     424    ((void)((*___dst__4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
     425    {
     426        signed int _index1 = 0;
     427        for (;(_index1<10);((void)(++_index1))) {
     428            ((void)((*___dst__4sVad_1).__anonymous_object34[_index1]=___src__4sVad_1.__anonymous_object34[_index1]) /* ?{} */);
     429        }
     430
     431    }
     432
     433    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
     434}
     435static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
     436    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ^?{} */);
     437    {
     438        signed int _index2 = (10-1);
     439        for (;(_index2>=0);((void)(--_index2))) {
     440            ((void)((*___dst__4sVad_1).__anonymous_object34[_index2]) /* ^?{} */);
     441        }
     442
     443    }
     444
     445    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ^?{} */);
     446    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ^?{} */);
     447}
     448static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
     449    struct Vad ___ret__4sVad_1;
     450    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
     451    ((void)((*___dst__4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33));
     452    {
     453        signed int _index3 = 0;
     454        for (;(_index3<10);((void)(++_index3))) {
     455            ((void)((*___dst__4sVad_1).__anonymous_object34[_index3]=___src__4sVad_1.__anonymous_object34[_index3]));
     456        }
     457
     458    }
     459
     460    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
     461    ((void)___constructor__F_4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__4sVad_1)));
     462    return ___ret__4sVad_1;
     463}
     464static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object46){
     465    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
     466    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
     467    {
     468        signed int _index4 = 0;
     469        for (;(_index4<10);((void)(++_index4))) {
     470            ((void)((*___dst__4sVad_1).__anonymous_object34[_index4]) /* ?{} */);
     471        }
     472
     473    }
     474
     475    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     476}
     477static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused,unused)) signed int *__anonymous_object48){
     478    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
     479    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
     480    {
     481        signed int _index5 = 0;
     482        for (;(_index5<10);((void)(++_index5))) {
     483            ((void)((*___dst__4sVad_1).__anonymous_object34[_index5]) /* ?{} */);
     484        }
     485
     486    }
     487
     488    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     489}
     490static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused,unused)) signed int *__anonymous_object50, __attribute__ ((unused,unused)) signed int __anonymous_object51[((unsigned int )10)]){
     491    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
     492    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
     493    {
     494        signed int _index6 = 0;
     495        for (;(_index6<10);((void)(++_index6))) {
     496            ((void)((*___dst__4sVad_1).__anonymous_object34[_index6]=__anonymous_object51[_index6]) /* ?{} */);
     497        }
     498
     499    }
     500
     501    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     502}
     503static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object52, __attribute__ ((unused,unused)) signed int *__anonymous_object53, __attribute__ ((unused,unused)) signed int __anonymous_object54[((unsigned int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object55)()){
     504    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
     505    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
     506    {
     507        signed int _index7 = 0;
     508        for (;(_index7<10);((void)(++_index7))) {
     509            ((void)((*___dst__4sVad_1).__anonymous_object34[_index7]=__anonymous_object54[_index7]) /* ?{} */);
     510        }
     511
     512    }
     513
     514    ((void)((*___dst__4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
     515}
  • src/tests/Makefile.am

    rfc20514 r777ed2b  
    1717debug=yes
    1818
    19 quick_test=avl_test operators numericConstants expression enum array typeof cast attributes
     19quick_test=avl_test operators numericConstants expression enum array typeof cast raii/dtor-early-exit raii/init_once attributes
    2020
    2121if BUILD_CONCURRENCY
     
    110110        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    111111
     112nested-types-ERR1: nested-types.c @CFA_BINDIR@/@CFA_NAME@
     113        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     114
     115nested-types-ERR2: nested-types.c @CFA_BINDIR@/@CFA_NAME@
     116        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}
     117
    112118# Constructor/destructor tests
    113119raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
  • src/tests/Makefile.in

    rfc20514 r777ed2b  
    303303top_srcdir = @top_srcdir@
    304304debug = yes
    305 quick_test = avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes
     305quick_test = avl_test operators numericConstants expression enum array typeof cast raii/dtor-early-exit raii/init_once attributes
    306306@BUILD_CONCURRENCY_FALSE@concurrent = '-Econcurrent'
    307307@BUILD_CONCURRENCY_TRUE@concurrent =
     
    787787        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    788788
     789nested-types-ERR1: nested-types.c @CFA_BINDIR@/@CFA_NAME@
     790        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     791
     792nested-types-ERR2: nested-types.c @CFA_BINDIR@/@CFA_NAME@
     793        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}
     794
    789795# Constructor/destructor tests
    790796raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
Note: See TracChangeset for help on using the changeset viewer.