Changeset c5d7701

Timestamp:

Jun 14, 2018, 5:34:39 PM (6 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:

704d11e

Parents:

29f9e20

Message:

Add QualifiedType? node

Location:

src

Files:

• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (1 diff)
• Parser/ParseNode.h (modified) (1 diff)
• 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

@@ -133 +133 @@
         virtual void visit( ArrayType * arrayType ) override final;
         virtual void visit( ReferenceType * referenceType ) override final;
+        virtual void visit( QualifiedType * qualType ) override final;
         virtual void visit( FunctionType * functionType ) override final;
         virtual void visit( StructInstType * aggregateUseType ) override final;
@@ -233 +234 @@
         virtual Type * mutate( ArrayType * arrayType ) override final;
         virtual Type * mutate( ReferenceType * referenceType ) override final;
+        virtual Type * mutate( QualifiedType * qualType ) override final;
         virtual Type * mutate( FunctionType * functionType ) override final;
         virtual Type * mutate( StructInstType * aggregateUseType ) override final;

src/Common/PassVisitor.impl.h

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

src/Parser/DeclarationNode.cc

@@ -253 +253 @@
         return newnode;
 } // DeclarationNode::newFromTypedef
+
+DeclarationNode * DeclarationNode::newQualifiedType( DeclarationNode * parent, DeclarationNode * child) {
+        return child;
+        // return parent->add_last( child );
+}
 
 DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {

src/Parser/ParseNode.h

@@ -231 +231 @@
         static DeclarationNode * newForall( DeclarationNode * );
         static DeclarationNode * newFromTypedef( const std::string * );
+        static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
         static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
         static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );

src/Parser/parser.yy

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

src/SynTree/Mutator.h

@@ -101 +101 @@
         virtual Type * mutate( ArrayType * arrayType ) = 0;
         virtual Type * mutate( ReferenceType * refType ) = 0;
+        virtual Type * mutate( QualifiedType * qualType ) = 0;
         virtual Type * mutate( FunctionType * functionType ) = 0;
         virtual Type * mutate( StructInstType * aggregateUseType ) = 0;

src/SynTree/SynTree.h

@@ -110 +110 @@
 class ArrayType;
 class ReferenceType;
+class QualifiedType;
 class FunctionType;
 class ReferenceToType;

src/SynTree/Type.cc

@@ -105 +105 @@
 }
 
+
+QualifiedType::QualifiedType( const Type::Qualifiers & tq, const std::list< Type * > & types ) : Type( tq, {} ), types( types ) {
+}
+
+QualifiedType::QualifiedType( const QualifiedType & other ) : Type( other ) {
+        cloneAll( other.types, types );
+}
+
+QualifiedType::~QualifiedType() {
+        deleteAll( types );
+}
+
+void QualifiedType::print( std::ostream & os, Indenter indent ) const {
+        os << "Qualified Type: ";
+        printAll( types, os, indent+1 );
+        Type::print( os, indent+1 );
+}
+
+
 // Empty Variable declarations:
 const Type::FuncSpecifiers noFuncSpecifiers;

src/SynTree/Type.h

@@ -315 +315 @@
 };
 
+class QualifiedType : public Type {
+public:
+        std::list<Type *> types;
+
+        QualifiedType( const Type::Qualifiers & tq, const std::list< Type * > & types );
+        QualifiedType( const QualifiedType & tq );
+        virtual ~QualifiedType();
+
+        virtual QualifiedType *clone() const override { return new QualifiedType( *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;
+};
+
 class ReferenceType : public Type {
 public:

src/SynTree/Visitor.h

@@ -103 +103 @@
         virtual void visit( ArrayType * arrayType ) = 0;
         virtual void visit( ReferenceType * refType ) = 0;
+        virtual void visit( QualifiedType * qualType ) = 0;
         virtual void visit( FunctionType * functionType ) = 0;
         virtual void visit( StructInstType * aggregateUseType ) = 0;