Line data    Source code

       1             : // Copyright 2012 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_AST_PRETTYPRINTER_H_
       6             : #define V8_AST_PRETTYPRINTER_H_
       7             : 
       8             : #include "src/allocation.h"
       9             : #include "src/ast/ast.h"
      10             : #include "src/base/compiler-specific.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : 
      15             : class IncrementalStringBuilder;  // to avoid including string-builder-inl.h
      16             : 
      17       12660 : class CallPrinter final : public AstVisitor<CallPrinter> {
      18             :  public:
      19             :   explicit CallPrinter(Isolate* isolate, bool is_user_js);
      20             :   ~CallPrinter();
      21             : 
      22             :   // The following routine prints the node with position |position| into a
      23             :   // string.
      24             :   Handle<String> Print(FunctionLiteral* program, int position);
      25             :   enum ErrorHint {
      26             :     kNone,
      27             :     kNormalIterator,
      28             :     kAsyncIterator,
      29             :     kCallAndNormalIterator,
      30             :     kCallAndAsyncIterator
      31             :   };
      32             :   ErrorHint GetErrorHint() const;
      33             : 
      34             : // Individual nodes
      35             : #define DECLARE_VISIT(type) void Visit##type(type* node);
      36             :   AST_NODE_LIST(DECLARE_VISIT)
      37             : #undef DECLARE_VISIT
      38             : 
      39             :  private:
      40             :   void Print(const char* str);
      41             :   void Print(Handle<String> str);
      42             : 
      43             :   void Find(AstNode* node, bool print = false);
      44             : 
      45             :   Isolate* isolate_;
      46             :   int num_prints_;
      47             :   // Allocate the builder on the heap simply because it's forward declared.
      48             :   std::unique_ptr<IncrementalStringBuilder> builder_;
      49             :   int position_;  // position of ast node to print
      50             :   bool found_;
      51             :   bool done_;
      52             :   bool is_user_js_;
      53             :   bool is_iterator_error_;
      54             :   bool is_async_iterator_error_;
      55             :   bool is_call_error_;
      56             :   FunctionKind function_kind_;
      57      594807 :   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
      58             : 
      59             :  protected:
      60             :   void PrintLiteral(Handle<Object> value, bool quote);
      61             :   void PrintLiteral(const AstRawString* value, bool quote);
      62             :   void FindStatements(const ZonePtrList<Statement>* statements);
      63             :   void FindArguments(const ZonePtrList<Expression>* arguments);
      64             : };
      65             : 
      66             : 
      67             : #ifdef DEBUG
      68             : 
      69             : class AstPrinter final : public AstVisitor<AstPrinter> {
      70             :  public:
      71             :   explicit AstPrinter(uintptr_t stack_limit);
      72             :   ~AstPrinter();
      73             : 
      74             :   // The following routines print a node into a string.
      75             :   // The result string is alive as long as the AstPrinter is alive.
      76             :   const char* Print(AstNode* node);
      77             :   const char* PrintProgram(FunctionLiteral* program);
      78             : 
      79             :   void PRINTF_FORMAT(2, 3) Print(const char* format, ...);
      80             : 
      81             :   // Print a node to stdout.
      82             :   static void PrintOut(Isolate* isolate, AstNode* node);
      83             : 
      84             :   // Individual nodes
      85             : #define DECLARE_VISIT(type) void Visit##type(type* node);
      86             :   AST_NODE_LIST(DECLARE_VISIT)
      87             : #undef DECLARE_VISIT
      88             : 
      89             :  private:
      90             :   friend class IndentedScope;
      91             : 
      92             :   void Init();
      93             : 
      94             :   void PrintLabels(ZonePtrList<const AstRawString>* labels);
      95             :   void PrintLiteral(const AstRawString* value, bool quote);
      96             :   void PrintLiteral(const AstConsString* value, bool quote);
      97             :   void PrintLiteral(Literal* literal, bool quote);
      98             :   void PrintIndented(const char* txt);
      99             :   void PrintIndentedVisit(const char* s, AstNode* node);
     100             : 
     101             :   void PrintStatements(const ZonePtrList<Statement>* statements);
     102             :   void PrintDeclarations(Declaration::List* declarations);
     103             :   void PrintParameters(DeclarationScope* scope);
     104             :   void PrintArguments(const ZonePtrList<Expression>* arguments);
     105             :   void PrintCaseClause(CaseClause* clause);
     106             :   void PrintLiteralIndented(const char* info, Literal* literal, bool quote);
     107             :   void PrintLiteralIndented(const char* info, const AstRawString* value,
     108             :                             bool quote);
     109             :   void PrintLiteralIndented(const char* info, const AstConsString* value,
     110             :                             bool quote);
     111             :   void PrintLiteralWithModeIndented(const char* info, Variable* var,
     112             :                                     const AstRawString* value);
     113             :   void PrintLabelsIndented(ZonePtrList<const AstRawString>* labels,
     114             :                            const char* prefix = "");
     115             :   void PrintObjectProperties(
     116             :       const ZonePtrList<ObjectLiteral::Property>* properties);
     117             :   void PrintClassProperties(
     118             :       const ZonePtrList<ClassLiteral::Property>* properties);
     119             : 
     120             :   void inc_indent() { indent_++; }
     121             :   void dec_indent() { indent_--; }
     122             : 
     123             :   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
     124             : 
     125             :   char* output_;  // output string buffer
     126             :   int size_;      // output_ size
     127             :   int pos_;       // current printing position
     128             :   int indent_;
     129             : };
     130             : 
     131             : #endif  // DEBUG
     132             : 
     133             : }  // namespace internal
     134             : }  // namespace v8
     135             : 
     136             : #endif  // V8_AST_PRETTYPRINTER_H_