external/bsd/llvm/dist/clang/lib/AST/InheritViz.cpp

   1 //===- InheritViz.cpp - Graphviz visualization for inheritance --*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements CXXRecordDecl::viewInheritance, which
  11 //  generates a GraphViz DOT file that depicts the class inheritance
  12 //  diagram and then calls Graphviz/dot+gv on it.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "clang/AST/ASTContext.h"
  17 #include "clang/AST/Decl.h"
  18 #include "clang/AST/DeclCXX.h"
  19 #include "clang/AST/TypeOrdering.h"
  20 #include "llvm/Support/FileSystem.h"
  21 #include "llvm/Support/GraphWriter.h"
  22 #include "llvm/Support/raw_ostream.h"
  23 #include <map>
  24 #include <set>
  25
  26 using namespace llvm;
  27
  28 namespace clang {
  29
  30 /// InheritanceHierarchyWriter - Helper class that writes out a
  31 /// GraphViz file that diagrams the inheritance hierarchy starting at
  32 /// a given C++ class type. Note that we do not use LLVM's
  33 /// GraphWriter, because the interface does not permit us to properly
  34 /// differentiate between uses of types as virtual bases
  35 /// vs. non-virtual bases.
  36 class InheritanceHierarchyWriter {
  37   ASTContext& Context;
  38   raw_ostream &Out;
  39   std::map<QualType, int, QualTypeOrdering> DirectBaseCount;
  40   std::set<QualType, QualTypeOrdering> KnownVirtualBases;
  41
  42 public:
  43   InheritanceHierarchyWriter(ASTContext& Context, raw_ostream& Out)
  44     : Context(Context), Out(Out) { }
  45
  46   void WriteGraph(QualType Type) {
  47     Out << "digraph \"" << DOT::EscapeString(Type.getAsString()) << "\" {\n";
  48     WriteNode(Type, false);
  49     Out << "}\n";
  50   }
  51
  52 protected:
  53   /// WriteNode - Write out the description of node in the inheritance
  54   /// diagram, which may be a base class or it may be the root node.
  55   void WriteNode(QualType Type, bool FromVirtual);
  56
  57   /// WriteNodeReference - Write out a reference to the given node,
  58   /// using a unique identifier for each direct base and for the
  59   /// (only) virtual base.
  60   raw_ostream& WriteNodeReference(QualType Type, bool FromVirtual);
  61 };
  62
  63 void InheritanceHierarchyWriter::WriteNode(QualType Type, bool FromVirtual) {
  64   QualType CanonType = Context.getCanonicalType(Type);
  65
  66   if (FromVirtual) {
  67     if (KnownVirtualBases.find(CanonType) != KnownVirtualBases.end())
  68       return;
  69
  70     // We haven't seen this virtual base before, so display it and
  71     // its bases.
  72     KnownVirtualBases.insert(CanonType);
  73   }
  74
  75   // Declare the node itself.
  76   Out << "  ";
  77   WriteNodeReference(Type, FromVirtual);
  78
  79   // Give the node a label based on the name of the class.
  80   std::string TypeName = Type.getAsString();
  81   Out << " [ shape=\"box\", label=\"" << DOT::EscapeString(TypeName);
  82
  83   // If the name of the class was a typedef or something different
  84   // from the "real" class name, show the real class name in
  85   // parentheses so we don't confuse ourselves.
  86   if (TypeName != CanonType.getAsString()) {
  87     Out << "\\n(" << CanonType.getAsString() << ")";
  88   }
  89
  90   // Finished describing the node.
  91   Out << " \"];\n";
  92
  93   // Display the base classes.
  94   const CXXRecordDecl *Decl
  95     = static_cast<const CXXRecordDecl *>(Type->getAs<RecordType>()->getDecl());
  96   for (const auto &Base : Decl->bases()) {
  97     QualType CanonBaseType = Context.getCanonicalType(Base.getType());
  98
  99     // If this is not virtual inheritance, bump the direct base
 100     // count for the type.
 101     if (!Base.isVirtual())
 102       ++DirectBaseCount[CanonBaseType];
 103
 104     // Write out the node (if we need to).
 105     WriteNode(Base.getType(), Base.isVirtual());
 106
 107     // Write out the edge.
 108     Out << "  ";
 109     WriteNodeReference(Type, FromVirtual);
 110     Out << " -> ";
 111     WriteNodeReference(Base.getType(), Base.isVirtual());
 112
 113     // Write out edge attributes to show the kind of inheritance.
 114     if (Base.isVirtual()) {
 115       Out << " [ style=\"dashed\" ]";
 116     }
 117     Out << ";";
 118   }
 119 }
 120
 121 /// WriteNodeReference - Write out a reference to the given node,
 122 /// using a unique identifier for each direct base and for the
 123 /// (only) virtual base.
 124 raw_ostream&
 125 InheritanceHierarchyWriter::WriteNodeReference(QualType Type,
 126                                                bool FromVirtual) {
 127   QualType CanonType = Context.getCanonicalType(Type);
 128
 129   Out << "Class_" << CanonType.getAsOpaquePtr();
 130   if (!FromVirtual)
 131     Out << "_" << DirectBaseCount[CanonType];
 132   return Out;
 133 }
 134
 135 /// viewInheritance - Display the inheritance hierarchy of this C++
 136 /// class using GraphViz.
 137 void CXXRecordDecl::viewInheritance(ASTContext& Context) const {
 138   QualType Self = Context.getTypeDeclType(this);
 139
 140   int FD;
 141   SmallString<128> Filename;
 142   std::error_code EC =
 143       sys::fs::createTemporaryFile(Self.getAsString(), "dot", FD, Filename);
 144   if (EC) {
 145     llvm::errs() << "Error: " << EC.message() << "\n";
 146     return;
 147   }
 148
 149   llvm::errs() << "Writing '" << Filename << "'... ";
 150
 151   llvm::raw_fd_ostream O(FD, true);
 152
 153   InheritanceHierarchyWriter Writer(Context, O);
 154   Writer.WriteGraph(Self);
 155   llvm::errs() << " done. \n";
 156
 157   O.close();
 158
 159   // Display the graph
 160   DisplayGraph(Filename);
 161 }
 162
 163 }