Changeset b0ec971 for src

Timestamp:

May 23, 2019, 11:27:57 AM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

68c9165

Parents:

c957e7f

Message:

Added ast::Type printers

Location:

src/AST

Files:

• Print.cpp (modified) (2 diffs)
• Type.hpp (modified) (6 diffs)

src/AST/Print.cpp

@@ -96 +96 @@
         }
 
+        void print( const ast::ParameterizedType::ForallList & forall ) {
+                if ( forall.empty() ) return;   
+                os << "forall" << std::endl;
+                ++indent;
+                printAll( forall );
+                os << indent;
+                --indent;
+        }
+
+        void print( const std::vector<ptr<Attribute>> & attrs ) {
+                if ( attrs.empty() ) return;
+                os << "with attributes" << std::endl;
+                ++indent;
+                printAll( attrs );
+                --indent;
+        }
+
+        void print( const std::vector<ptr<Expr>> & params ) {
+                if ( params.empty() ) return;
+                os << std::endl << indent << "... with parameters" << std::endl;
+                ++indent;
+                printAll( params );
+                --indent;
+        }
+
+        void preprint( const ast::Type * node ) {
+                print( node->qualifiers );
+        }
+
+        void preprint( const ast::ParameterizedType * node ) {
+                print( node->forall );
+                print( node->qualifiers );
+        }
+
+        void preprint( const ast::ReferenceToType * node ) {
+                print( node->forall );
+                print( node->attributes );
+                print( node->qualifiers );
+        }
+
 public:
         virtual const ast::DeclWithType *     visit( const ast::ObjectDecl           * node ) {
@@ -404 +444 @@
 
         virtual const ast::Type *             visit( const ast::VoidType             * node ) {
+                preprint( node );
+                os << "void";
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::BasicType            * node ) {
+                preprint( node );
+                os << ast::BasicType::typeNames[ node->kind ];
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::PointerType          * node ) {
+                preprint( node );
+                if ( ! node->isArray() ) {
+                        os << "pointer to ";
+                } else {
+                        os << "decayed ";
+                        if ( node->isStatic ) {
+                                os << "static ";
+                        }
+
+                        if ( node->isVarLen ) {
+                                os << "variable length array of ";
+                        } else if ( node->dimension ) {
+                                os << "array of ";
+                                node->dimension->accept( *this );
+                                os << " ";
+                        }
+                }
+
+                if ( node->base ) {
+                        node->base->accept( *this );
+                } else {
+                        os << "UNDEFINED";
+                }
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::ArrayType            * node ) {
+                preprint( node );
+                if ( node->isStatic ) {
+                        os << "static ";
+                }
+
+                if ( node->isVarLen ) {
+                        os << "variable length array of ";
+                } else if ( node->dimension ) {
+                        os << "array of ";
+                } else {
+                        os << "open array of ";
+                }
+
+                if ( node->base ) {
+                        node->base->accept( *this );
+                } else {
+                        os << "UNDEFINED";
+                }
+
+                if ( node->dimension ) {
+                        os << " with dimension of ";
+                        node->dimension->accept( *this );
+                }
+
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::ReferenceType        * node ) {
+                preprint( node );
+
+                os << "reference to ";
+                if ( node->base ) {
+                        node->base->accept( *this );
+                } else {
+                        os << "UNDEFINED";
+                }
+
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::QualifiedType        * node ) {
+                preprint( node );
+
+                ++indent;
+                os << "Qualified Type:" << std::endl << indent;
+                node->parent->accept( *this );
+                os << std::endl << indent;
+                node->child->accept( *this );
+                os << std::endl;
+                --indent;
+
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::FunctionType         * node ) {
+                preprint( node );
+
+                os << "function" << std::endl;
+                if ( ! node->params.empty() ) {
+                        os << indent << "... with parameters" << std::endl;
+                        ++indent;
+                        printAll( node->params );
+                        if ( node->isVarArgs ) {
+                                os << indent << "and a variable number of other arguments" << std::endl;
+                        }
+                        --indent;
+                } else if ( node->isVarArgs ) {
+                        os << indent+1 << "accepting unspecified arguments" << std::endl;
+                }
+
+                os << indent << "... returning";
+                if ( node->returns.empty() ) {
+                        os << " nothing" << std::endl;
+                } else {
+                        os << std::endl;
+                        ++indent;
+                        printAll( node->returns );
+                        --indent;
+                }
+
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::StructInstType       * node ) {
+                preprint( node );
+
+                os << "instance of struct " << node->name;
+                if ( node->base ) {
+                        os << " " << ( node->base->body ? "with" : "without" ) << " body";
+                }
+                print( node->params );
+
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::UnionInstType        * node ) {
+                preprint( node );
+
+                os << "instance of union " << node->name;
+                if ( node->base ) {
+                        os << " " << ( node->base->body ? "with" : "without" ) << " body";
+                }
+                print( node->params );
+
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::EnumInstType         * node ) {
+                preprint( node );
+
+                os << "instance of enum " << node->name;
+                if ( node->base ) {
+                        os << " " << ( node->base->body ? "with" : "without" ) << " body";
+                }
+                print( node->params );
+
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::TraitInstType        * node ) {
+                preprint( node );
+
+                os << "instance of trait " << node->name;
+                print( node->params );
+
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::TypeInstType         * node ) {
+                preprint( node );
+
+                os << "instance of type " << node->name 
+                   << " (" << (node->kind == ast::TypeVar::Ftype ? "" : "not ") << "function type)";
+                print( node->params );
+
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::TupleType            * node ) {
+                preprint( node );
+
+                os << "tuple of types" << std::endl;
+                ++indent;
+                printAll( node->types );
+                --indent;
+
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::TypeofType           * node ) {
+                preprint( node );
+
+                if ( node->kind == ast::TypeofType::Basetypeof ) { os << "base-"; }
+                os << "type-of expression ";
+                if ( node->expr ) {
+                        node->expr->accept( *this );
+                } else {
+                        os << "UNDEFINED";
+                }
+
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::VarArgsType          * node ) {
+                preprint( node );
+                os << "builtin var args pack";
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::ZeroType             * node ) {
+                preprint( node );
+                os << "zero_t";
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::OneType              * node ) {
+                preprint( node );
+                os << "one_t";
                 return node;
         }
 
         virtual const ast::Type *             visit( const ast::GlobalScopeType      * node ) {
+                preprint( node );
+                os << "Global Scope Type";
                 return node;
         }

src/AST/Type.hpp

@@ -308 +308 @@
         virtual ReferenceToType * clone() const override = 0;
         MUTATE_FRIEND
-
-protected:
-        /// Name for the kind of type this is
-        virtual std::string typeString() const = 0;
 };
 
@@ -333 +329 @@
         StructInstType * clone() const override { return new StructInstType{ *this }; }
         MUTATE_FRIEND
-
-        std::string typeString() const override { return "struct"; }
 };
 
@@ -356 +350 @@
         UnionInstType * clone() const override { return new UnionInstType{ *this }; }
         MUTATE_FRIEND
-
-        std::string typeString() const override { return "union"; }
 };
 
@@ -379 +371 @@
         EnumInstType * clone() const override { return new EnumInstType{ *this }; }
         MUTATE_FRIEND
-
-        std::string typeString() const override { return "enum"; }
 };
 
@@ -403 +393 @@
         TraitInstType * clone() const override { return new TraitInstType{ *this }; }
         MUTATE_FRIEND
-
-        std::string typeString() const override { return "trait"; }
 };
 
@@ -432 +420 @@
         TypeInstType * clone() const override { return new TypeInstType{ *this }; }
         MUTATE_FRIEND
-
-        std::string typeString() const override { return "type"; }
 };