Changeset 47498bd


Ignore:
Timestamp:
Jun 19, 2018, 2:11:38 PM (3 years ago)
Author:
Rob Schluntz <rschlunt@…>
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:
9a7a3b6
Parents:
704d11e
Message:

Add nodes for global scope type

Location:
src
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • src/Common/PassVisitor.h

    r704d11e r47498bd  
    146146        virtual void visit( ZeroType * zeroType ) override final;
    147147        virtual void visit( OneType * oneType ) override final;
     148        virtual void visit( GlobalScopeType * globalType ) override final;
    148149
    149150        virtual void visit( Designation * designation ) override final;
     
    247248        virtual Type * mutate( ZeroType * zeroType ) override final;
    248249        virtual Type * mutate( OneType * oneType ) override final;
     250        virtual Type * mutate( GlobalScopeType * globalType ) override final;
    249251
    250252        virtual Designation * mutate( Designation * designation ) override final;
  • src/Common/PassVisitor.impl.h

    r704d11e r47498bd  
    25762576
    25772577//--------------------------------------------------------------------------
     2578// GlobalScopeType
     2579template< typename pass_type >
     2580void PassVisitor< pass_type >::visit( GlobalScopeType * node ) {
     2581        VISIT_START( node );
     2582
     2583        maybeAccept_impl( node->forall, *this );
     2584
     2585        VISIT_END( node );
     2586}
     2587
     2588template< typename pass_type >
     2589Type * PassVisitor< pass_type >::mutate( GlobalScopeType * node ) {
     2590        MUTATE_START( node );
     2591
     2592        maybeMutate_impl( node->forall, *this );
     2593
     2594        MUTATE_END( Type, node );
     2595}
     2596
     2597//--------------------------------------------------------------------------
    25782598// Designation
    25792599template< typename pass_type >
  • src/Parser/DeclarationNode.cc

    r704d11e r47498bd  
    253253        return newnode;
    254254} // DeclarationNode::newFromTypedef
     255
     256DeclarationNode * DeclarationNode::newFromGlobalScope() {
     257        DeclarationNode * newnode = new DeclarationNode;
     258        newnode->type = new TypeData( TypeData::GlobalScope );
     259        return newnode;
     260}
    255261
    256262DeclarationNode * DeclarationNode::newQualifiedType( DeclarationNode * parent, DeclarationNode * child) {
     
    9981004                try {
    9991005                        Declaration * decl = cur->build();
    1000                         if ( decl ) {
    1001                                 if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
    1002                                         dwt->location = cur->location;
    1003                                         * out++ = dwt;
    1004                                 } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
    1005                                         StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->name );
    1006                                         auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
    1007                                         obj->location = cur->location;
    1008                                         * out++ = obj;
    1009                                         delete agg;
    1010                                 } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
    1011                                         UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->name );
    1012                                         auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
    1013                                         obj->location = cur->location;
    1014                                         * out++ = obj;
    1015                                 } // if
     1006                        assert( decl );
     1007                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
     1008                                dwt->location = cur->location;
     1009                                * out++ = dwt;
     1010                        } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
     1011                                // xxx - this might be where anonymous struct members are added - should be conditional on struct name
     1012                                StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->name );
     1013                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
     1014                                obj->location = cur->location;
     1015                                * out++ = obj;
     1016                                delete agg;
     1017                        } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
     1018                                UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->name );
     1019                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
     1020                                obj->location = cur->location;
     1021                                * out++ = obj;
    10161022                        } // if
    10171023                } catch( SemanticErrorException &e ) {
  • src/Parser/ParseNode.h

    r704d11e r47498bd  
    231231        static DeclarationNode * newForall( DeclarationNode * );
    232232        static DeclarationNode * newFromTypedef( const std::string * );
     233        static DeclarationNode * newFromGlobalScope();
    233234        static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
    234235        static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
  • src/Parser/TypeData.cc

    r704d11e r47498bd  
    3737          case Reference:
    3838          case EnumConstant:
     39          case GlobalScope:
    3940                // nothing else to initialize
    4041                break;
     
    112113          case Reference:
    113114          case EnumConstant:
     115          case GlobalScope:
    114116                // nothing to destroy
    115117                break;
     
    180182          case Pointer:
    181183          case Reference:
     184          case GlobalScope:
    182185                // nothing else to copy
    183186                break;
  • src/Parser/TypeData.h

    r704d11e r47498bd  
    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, Unknown };
    3030
    3131        struct Aggregate_t {
     
    8888        DeclarationNode * forall;
    8989
    90         // Basic_t basic;
    9190        Aggregate_t aggregate;
    9291        AggInst_t aggInst;
    9392        Array_t array;
    9493        Enumeration_t enumeration;
    95         // Variable_t variable;
    9694        Function_t function;
    9795        Symbolic_t symbolic;
  • src/Parser/parser.yy

    r704d11e r47498bd  
    17921792                { $$ = DeclarationNode::newFromTypedef( $1 ); }
    17931793        | '.' TYPEDEFname
    1794                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     1794                { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), DeclarationNode::newFromTypedef( $2 ) ); }
    17951795        | type_name '.' TYPEDEFname
    17961796                { $$ = DeclarationNode::newQualifiedType( $1, DeclarationNode::newFromTypedef( $3 ) ); }
    17971797        | typegen_name
    17981798        | '.' typegen_name
    1799                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     1799                { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), $2 ); }
    18001800        | type_name '.' typegen_name
    18011801                { $$ = DeclarationNode::newQualifiedType( $1, $3 ); }
  • src/SynTree/Mutator.h

    r704d11e r47498bd  
    114114        virtual Type * mutate( ZeroType * zeroType ) = 0;
    115115        virtual Type * mutate( OneType * oneType ) = 0;
     116        virtual Type * mutate( GlobalScopeType * globalType ) = 0;
    116117
    117118        virtual Designation * mutate( Designation * designation ) = 0 ;
  • src/SynTree/SynTree.h

    r704d11e r47498bd  
    124124class ZeroType;
    125125class OneType;
     126class GlobalScopeType;
    126127
    127128class Designation;
  • src/SynTree/Type.cc

    r704d11e r47498bd  
    118118
    119119void QualifiedType::print( std::ostream & os, Indenter indent ) const {
    120         os << "Qualified Type: ";
     120        os << "Qualified Type: " << endl;
    121121        printAll( types, os, indent+1 );
    122122        Type::print( os, indent+1 );
     123}
     124
     125GlobalScopeType::GlobalScopeType() : Type( Type::Qualifiers(), {} ) {}
     126
     127void GlobalScopeType::print( std::ostream & os, Indenter indent ) const {
     128        os << "Global Scope Type" << endl;
    123129}
    124130
  • src/SynTree/Type.h

    r704d11e r47498bd  
    679679};
    680680
     681class GlobalScopeType : public Type {
     682  public:
     683        GlobalScopeType();
     684
     685        virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
     686        virtual void accept( Visitor & v ) override { v.visit( this ); }
     687        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     688        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     689};
     690
    681691// Local Variables: //
    682692// tab-width: 4 //
  • src/SynTree/Visitor.h

    r704d11e r47498bd  
    116116        virtual void visit( ZeroType * zeroType ) = 0;
    117117        virtual void visit( OneType * oneType ) = 0;
     118        virtual void visit( GlobalScopeType * globalType ) = 0;
    118119
    119120        virtual void visit( Designation * designation ) = 0;
Note: See TracChangeset for help on using the changeset viewer.