Changeset 47498bd for src

Timestamp:

Jun 19, 2018, 2:11:38 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

9a7a3b6

Parents:

704d11e

Message:

Add nodes for global scope type

Location:

src

Files:

• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/TypeData.cc (modified) (3 diffs)
• Parser/TypeData.h (modified) (2 diffs)
• Parser/parser.yy (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Type.cc (modified) (1 diff)
• SynTree/Type.h (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)

src/Common/PassVisitor.h

@@ -146 +146 @@
         virtual void visit( ZeroType * zeroType ) override final;
         virtual void visit( OneType * oneType ) override final;
+        virtual void visit( GlobalScopeType * globalType ) override final;
 
         virtual void visit( Designation * designation ) override final;
@@ -247 +248 @@
         virtual Type * mutate( ZeroType * zeroType ) override final;
         virtual Type * mutate( OneType * oneType ) override final;
+        virtual Type * mutate( GlobalScopeType * globalType ) override final;
 
         virtual Designation * mutate( Designation * designation ) override final;

src/Common/PassVisitor.impl.h

@@ -2576 +2576 @@
 
 //--------------------------------------------------------------------------
+// GlobalScopeType
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( GlobalScopeType * node ) {
+        VISIT_START( node );
+
+        maybeAccept_impl( node->forall, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( GlobalScopeType * node ) {
+        MUTATE_START( node );
+
+        maybeMutate_impl( node->forall, *this );
+
+        MUTATE_END( Type, node );
+}
+
+//--------------------------------------------------------------------------
 // Designation
 template< typename pass_type >

src/Parser/DeclarationNode.cc

@@ -253 +253 @@
         return newnode;
 } // DeclarationNode::newFromTypedef
+
+DeclarationNode * DeclarationNode::newFromGlobalScope() {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::GlobalScope );
+        return newnode;
+}
 
 DeclarationNode * DeclarationNode::newQualifiedType( DeclarationNode * parent, DeclarationNode * child) {
@@ -998 +1004 @@
                 try {
                         Declaration * decl = cur->build();
-                        if ( decl ) {
-                                if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
-                                        dwt->location = cur->location;
-                                        * out++ = dwt;
-                                } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
-                                        StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->name );
-                                        auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
-                                        obj->location = cur->location;
-                                        * out++ = obj;
-                                        delete agg;
-                                } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
-                                        UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->name );
-                                        auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
-                                        obj->location = cur->location;
-                                        * out++ = obj;
-                                } // if
+                        assert( decl );
+                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                                dwt->location = cur->location;
+                                * out++ = dwt;
+                        } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
+                                // xxx - this might be where anonymous struct members are added - should be conditional on struct name
+                                StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->name );
+                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                obj->location = cur->location;
+                                * out++ = obj;
+                                delete agg;
+                        } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
+                                UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->name );
+                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                obj->location = cur->location;
+                                * out++ = obj;
                         } // if
                 } catch( SemanticErrorException &e ) {

src/Parser/ParseNode.h

@@ -231 +231 @@
         static DeclarationNode * newForall( DeclarationNode * );
         static DeclarationNode * newFromTypedef( const std::string * );
+        static DeclarationNode * newFromGlobalScope();
         static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
         static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );

src/Parser/TypeData.cc

@@ -37 +37 @@
           case Reference:
           case EnumConstant:
+          case GlobalScope:
                 // nothing else to initialize
                 break;
@@ -112 +113 @@
           case Reference:
           case EnumConstant:
+          case GlobalScope:
                 // nothing to destroy
                 break;
@@ -180 +182 @@
           case Pointer:
           case Reference:
+          case GlobalScope:
                 // nothing else to copy
                 break;

src/Parser/TypeData.h

@@ -27 +27 @@
 struct TypeData {
         enum Kind { Basic, Pointer, Array, Reference, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
-                                SymbolicInst, Tuple, Typeof, Builtin, Unknown };
+                                SymbolicInst, Tuple, Typeof, Builtin, GlobalScope, Unknown };
 
         struct Aggregate_t {
@@ -88 +88 @@
         DeclarationNode * forall;
 
-        // Basic_t basic;
         Aggregate_t aggregate;
         AggInst_t aggInst;
         Array_t array;
         Enumeration_t enumeration;
-        // Variable_t variable;
         Function_t function;
         Symbolic_t symbolic;

src/Parser/parser.yy

@@ -1792 +1792 @@
                 { $$ = DeclarationNode::newFromTypedef( $1 ); }
         | '.' TYPEDEFname
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), DeclarationNode::newFromTypedef( $2 ) ); }
         | type_name '.' TYPEDEFname
                 { $$ = DeclarationNode::newQualifiedType( $1, DeclarationNode::newFromTypedef( $3 ) ); }
         | typegen_name
         | '.' typegen_name
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), $2 ); }
         | type_name '.' typegen_name
                 { $$ = DeclarationNode::newQualifiedType( $1, $3 ); }

src/SynTree/Mutator.h

@@ -114 +114 @@
         virtual Type * mutate( ZeroType * zeroType ) = 0;
         virtual Type * mutate( OneType * oneType ) = 0;
+        virtual Type * mutate( GlobalScopeType * globalType ) = 0;
 
         virtual Designation * mutate( Designation * designation ) = 0 ;

src/SynTree/SynTree.h

@@ -124 +124 @@
 class ZeroType;
 class OneType;
+class GlobalScopeType;
 
 class Designation;

src/SynTree/Type.cc

@@ -118 +118 @@
 
 void QualifiedType::print( std::ostream & os, Indenter indent ) const {
-        os << "Qualified Type: ";
+        os << "Qualified Type: " << endl;
         printAll( types, os, indent+1 );
         Type::print( os, indent+1 );
+}
+
+GlobalScopeType::GlobalScopeType() : Type( Type::Qualifiers(), {} ) {}
+
+void GlobalScopeType::print( std::ostream & os, Indenter indent ) const {
+        os << "Global Scope Type" << endl;
 }
 

src/SynTree/Type.h

@@ -679 +679 @@
 };
 
+class GlobalScopeType : public Type {
+  public:
+        GlobalScopeType();
+
+        virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Visitor.h

@@ -116 +116 @@
         virtual void visit( ZeroType * zeroType ) = 0;
         virtual void visit( OneType * oneType ) = 0;
+        virtual void visit( GlobalScopeType * globalType ) = 0;
 
         virtual void visit( Designation * designation ) = 0;