LCOV - code coverage report
Current view: top level - gcc/go/gofrontend - ast-dump.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 0 8 0.0 %
Date: 2020-07-04 13:15:35 Functions: 0 0 -
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // ast-dump.h -- AST debug dump.    -*- C++ -*-
       2                 :            : 
       3                 :            : // Copyright 2011 The Go Authors. All rights reserved.
       4                 :            : // Use of this source code is governed by a BSD-style
       5                 :            : // license that can be found in the LICENSE file.
       6                 :            : 
       7                 :            : #ifndef GO_AST_DUMP_H
       8                 :            : #define GO_AST_DUMP_H
       9                 :            : 
      10                 :            : #include "string-dump.h"
      11                 :            : 
      12                 :            : class Expression;
      13                 :            : class Expression_list;
      14                 :            : class Named_object;
      15                 :            : class Statement;
      16                 :            : class Gogo;
      17                 :            : 
      18                 :            : // This class implements fgo-dump-ast. the
      19                 :            : // Abstract syntax tree dump of the Go program.
      20                 :            : 
      21                 :            : class Ast_dump_context : public String_dump
      22                 :            : {
      23                 :            :  public:
      24                 :            :   Ast_dump_context(std::ostream* out = NULL, bool dump_subblocks = true);
      25                 :            : 
      26                 :            :   // Initialize the dump context.
      27                 :            :   void
      28                 :            :   dump(Gogo*, const char* basename);
      29                 :            : 
      30                 :            :   // Dump spaces to dumpfile as indentation.
      31                 :            :   void
      32                 :            :   print_indent();
      33                 :            : 
      34                 :            :   // Increase current indentation for print_indent().
      35                 :            :   void
      36                 :          0 :   indent()
      37                 :          0 :   { ++this->indent_;}
      38                 :            : 
      39                 :            :   // Decrease current indentation for print_indent().
      40                 :            :   void
      41                 :          0 :   unindent()
      42                 :          0 :   { --this->indent_;}
      43                 :            : 
      44                 :            :   // Whether subblocks should be dumped or not.
      45                 :            :   bool
      46                 :          0 :   dump_subblocks()
      47                 :          0 :   { return this->dump_subblocks_; }
      48                 :            : 
      49                 :            :   // Get dump output stream.
      50                 :            :   std::ostream&
      51                 :          0 :   ostream()
      52                 :          0 :   { return *this->ostream_;}
      53                 :            : 
      54                 :            :   // Dump a Block to dump file.
      55                 :            :   void
      56                 :            :   dump_block(Block*);
      57                 :            : 
      58                 :            :   // Dump a type to dump file.
      59                 :            :   void
      60                 :            :   dump_type(const Type*);
      61                 :            : 
      62                 :            :   // Dump an expression to dump file.
      63                 :            :   void
      64                 :            :   dump_expression(const Expression*);
      65                 :            : 
      66                 :            :   // Dump an expression list to dump file.
      67                 :            :   void
      68                 :            :   dump_expression_list(const Expression_list*, bool as_pairs = false);
      69                 :            : 
      70                 :            :   // Dump a typed identifier to dump file.
      71                 :            :   void
      72                 :            :   dump_typed_identifier(const  Typed_identifier*);
      73                 :            : 
      74                 :            :   // Dump a typed identifier list to dump file.
      75                 :            :   void
      76                 :            :   dump_typed_identifier_list(const Typed_identifier_list*);
      77                 :            : 
      78                 :            :   // Dump temporary variable name to dump file.
      79                 :            :   void
      80                 :            :   dump_temp_variable_name(const Statement*);
      81                 :            : 
      82                 :            :   // Dump unamed lable name to dump file.
      83                 :            :   void
      84                 :            :   dump_label_name(const Unnamed_label*);
      85                 :            : 
      86                 :            :   // Dump operator symbol to dump file.
      87                 :            :   void
      88                 :            :   dump_operator(Operator);
      89                 :            : 
      90                 :            :   // Implementation of String_dump interface.
      91                 :            :   void
      92                 :            :   write_c_string(const char*);
      93                 :            : 
      94                 :            :   // Implements the String_dump interface.
      95                 :            :   void
      96                 :            :   write_string(const std::string& s);
      97                 :            : 
      98                 :            :   // Dump statement to stream.
      99                 :            :   static void
     100                 :            :   dump_to_stream(const Statement*, std::ostream*);
     101                 :            : 
     102                 :            :   // Dump expression to stream.
     103                 :            :   static void
     104                 :            :   dump_to_stream(const Expression* expr, std::ostream* out);
     105                 :            : 
     106                 :            :  private:
     107                 :            :    // Current indent level.
     108                 :            :   int indent_;
     109                 :            : 
     110                 :            :   // Indentation offset.
     111                 :            :   static const int offset_;
     112                 :            : 
     113                 :            :   // Whether subblocks of composite statements should be dumped or not.
     114                 :            :   bool dump_subblocks_;
     115                 :            : 
     116                 :            :   // Stream on output dump file.
     117                 :            :   std::ostream* ostream_;
     118                 :            : 
     119                 :            :   Gogo* gogo_;
     120                 :            : };
     121                 :            : 
     122                 :            : #endif  // GO_AST_DUMP_H

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.