Changeset 24d6572 for src/AST/Print.cpp

Timestamp:

Jun 12, 2023, 2:45:32 PM (2 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ast-experimental, master

Children:

62d62db

Parents:

34b4268 (diff), 251ce80 (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:

Merge branch 'master' into ast-experimental

File:

• src/AST/Print.cpp (modified) (16 diffs)

src/AST/Print.cpp

@@ -16 +16 @@
 #include "Print.hpp"
 
+#include "Attribute.hpp"
 #include "Decl.hpp"
 #include "Expr.hpp"
+#include "Init.hpp"
 #include "Stmt.hpp"
 #include "Type.hpp"
 #include "TypeSubstitution.hpp"
 #include "CompilationState.h"
-
-#include "Common/utility.h" // for group_iterate
+#include "Common/Iterate.hpp"
 
 using namespace std;
@@ -29 +30 @@
 namespace ast {
 
-template <typename C, typename... T>
-constexpr array<C,sizeof...(T)> make_array(T&&... values)
-{
-        return array<C,sizeof...(T)>{
-                std::forward<T>(values)...
-        };
+namespace {
+
+template<typename C, typename... T>
+constexpr array<C, sizeof...(T)> make_array( T&&... values ) {
+        return array<C, sizeof...(T)>{ std::forward<T>( values )... };
+}
+
+namespace Names {
+        static constexpr auto FuncSpecifiers = make_array<const char*>(
+                "inline", "_Noreturn", "fortran"
+        );
+
+        static constexpr auto StorageClasses = make_array<const char*>(
+                "extern", "static", "auto", "register", "__thread", "_Thread_local"
+        );
+
+        static constexpr auto Qualifiers = make_array<const char*>(
+                "const", "restrict", "volatile", "mutex", "_Atomic"
+        );
+}
+
+template<typename bits_t, size_t N>
+void print( ostream & os, const bits_t & bits,
+                const array<const char *, N> & names ) {
+        if ( !bits.any() ) return;
+        for ( size_t i = 0 ; i < N ; i += 1 ) {
+                if ( bits[i] ) {
+                        os << names[i] << ' ';
+                }
+        }
 }
 
@@ -80 +105 @@
         static const char* Names[];
 
-        struct Names {
-                static constexpr auto FuncSpecifiers = make_array<const char*>(
-                        "inline", "_Noreturn", "fortran"
-                );
-
-                static constexpr auto StorageClasses = make_array<const char*>(
-                        "extern", "static", "auto", "register", "__thread", "_Thread_local"
-                );
-
-                static constexpr auto Qualifiers = make_array<const char*>(
-                        "const", "restrict", "volatile", "mutex", "_Atomic"
-                );
-        };
-
-        template<typename storage_t, size_t N>
-        void print(const storage_t & storage, const array<const char *, N> & Names ) {
-                if ( storage.any() ) {
-                        for ( size_t i = 0; i < Names.size(); i += 1 ) {
-                                if ( storage[i] ) {
-                                        os << Names[i] << ' ';
-                                }
-                        }
-                }
-        }
-
-        void print( const ast::Function::Specs & specs ) {
-                print(specs, Names::FuncSpecifiers);
-        }
-
-        void print( const ast::Storage::Classes & storage ) {
-                print(storage, Names::StorageClasses);
-        }
-
-        void print( const ast::CV::Qualifiers & qualifiers ) {
-                print(qualifiers, Names::Qualifiers);
-        }
-
         void print( const std::vector<ast::Label> & labels ) {
                 if ( labels.empty() ) return;
@@ -221 +209 @@
         }
 
+    void print( const ast::WaitStmt * node ) {
+                if ( node->timeout_time ) {
+                        os << indent-1 << "timeout of:" << endl;
+                        node->timeout_time->accept( *this );
+
+                        if ( node->timeout_stmt ) {
+                                os << indent-1 << "... with statment:" << endl;
+                                node->timeout_stmt->accept( *this );
+                        }
+
+                        if ( node->timeout_cond ) {
+                                os << indent-1 << "... with condition:" << endl;
+                                node->timeout_cond->accept( *this );
+                        }
+                }
+
+                if ( node->else_stmt ) {
+                        os << indent-1 << "else:" << endl;
+                        node->else_stmt->accept( *this );
+
+                        if ( node->else_cond ) {
+                                os << indent-1 << "... with condition:" << endl;
+                                node->else_cond->accept( *this );
+                        }
+                }
+        }
+
         void preprint( const ast::NamedTypeDecl * node ) {
                 if ( ! node->name.empty() ) {
@@ -230 +245 @@
                 }
 
-                print( node->storage );
+                ast::print( os, node->storage );
                 os << node->typeString();
 
@@ -272 +287 @@
 
         void preprint( const ast::Type * node ) {
-                print( node->qualifiers );
+                ast::print( os, node->qualifiers );
         }
 
@@ -278 +293 @@
                 print( node->forall );
                 print( node->assertions );
-                print( node->qualifiers );
+                ast::print( os, node->qualifiers );
         }
 
         void preprint( const ast::BaseInstType * node ) {
                 print( node->attributes );
-                print( node->qualifiers );
+                ast::print( os, node->qualifiers );
         }
 
@@ -294 +309 @@
                 }
 
-                print( node->storage );
+                ast::print( os, node->storage );
 
                 if ( node->type ) {
@@ -338 +353 @@
                 if ( ! short_mode ) printAll( node->attributes );
 
-                print( node->storage );
-                print( node->funcSpec );
-
-
+                ast::print( os, node->storage );
+                ast::print( os, node->funcSpec );
 
                 if ( node->type && node->isTypeFixed ) {
@@ -384 +397 @@
                                 --indent;
                         }
+                }
+
+                if ( ! node->withExprs.empty() ) {
+                        // Not with a clause, but the 'with clause'.
+                        ++indent;
+                        os << " with clause" << endl << indent;
+                        printAll( node->withExprs );
+                        --indent;
                 }
 
@@ -746 +767 @@
         virtual const ast::Stmt * visit( const ast::SuspendStmt * node ) override final {
                 os << "Suspend Statement";
-                switch (node->type) {
-                        case ast::SuspendStmt::None     : os << " with implicit target"; break;
-                        case ast::SuspendStmt::Generator: os << " for generator"; break;
-                        case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
+                switch (node->kind) {
+                case ast::SuspendStmt::None     : os << " with implicit target"; break;
+                case ast::SuspendStmt::Generator: os << " for generator"; break;
+                case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
                 }
                 os << endl;
@@ -759 +780 @@
                 }
                 ++indent;
+
+                return node;
+        }
+
+        virtual const ast::WhenClause * visit( const ast::WhenClause * node ) override final {
+                os << indent-1 << "target: ";
+                safe_print( node->target );
+
+                if ( node->stmt ) {
+                        os << indent-1 << "... with statment:" << endl;
+                        node->stmt->accept( *this );
+                }
+
+                if ( node->when_cond ) {
+                        os << indent-1 << "... with when condition:" << endl;
+                        node->when_cond->accept( *this );
+                }
 
                 return node;
@@ -800 +838 @@
         virtual const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
                 os << indent-1 << "target function: ";
-                safe_print( node->target_func );
+                safe_print( node->target );
 
                 if ( !node->target_args.empty() ) {
@@ -814 +852 @@
                 }
 
-                if ( node->cond ) {
+                if ( node->when_cond ) {
                         os << indent-1 << "... with condition:" << endl;
-                        node->cond->accept( *this );
-                }
-
+                        node->when_cond->accept( *this );
+                }
+
+                return node;
+        }
+
+    virtual const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final {
+                os << "Waituntil Statement" << endl;
+                indent += 2;
+                for( const auto & clause : node->clauses ) {
+                        clause->accept( *this );
+                }
+        print(node);    // calls print( const ast::WaitStmt * node )
                 return node;
         }
@@ -1627 +1675 @@
 };
 
+} // namespace
+
 void print( ostream & os, const ast::Node * node, Indenter indent ) {
         Printer printer { os, indent, false };
@@ -1637 +1687 @@
 }
 
-// Annoyingly these needed to be defined out of line to avoid undefined references.
-// The size here needs to be explicit but at least the compiler will produce an error
-// if the wrong size is specified
-constexpr array<const char*, 3> Printer::Names::FuncSpecifiers;
-constexpr array<const char*, 6> Printer::Names::StorageClasses;
-constexpr array<const char*, 5> Printer::Names::Qualifiers;
+void print( ostream & os, Function::Specs specs ) {
+        print( os, specs, Names::FuncSpecifiers );
 }
+
+void print( ostream & os, Storage::Classes storage ) {
+        print( os, storage, Names::StorageClasses );
+}
+
+void print( ostream & os, CV::Qualifiers qualifiers ) {
+        print( os, qualifiers, Names::Qualifiers );
+}
+
+} // namespace ast