1//===--- PrettyPrinter.h - Classes for aiding with AST printing -*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file defines helper types for AST pretty-printing. 10// 11//===----------------------------------------------------------------------===// 12 13#ifndef LLVM_CLANG_AST_PRETTYPRINTER_H 14#define LLVM_CLANG_AST_PRETTYPRINTER_H 15 16#include "clang/Basic/LLVM.h" 17#include "clang/Basic/LangOptions.h" 18 19namespace clang { 20 21class LangOptions; 22class SourceManager; 23class Stmt; 24class TagDecl; 25 26class PrinterHelper { 27public: 28 virtual ~PrinterHelper(); 29 virtual bool handledStmt(Stmt* E, raw_ostream& OS) = 0; 30}; 31 32/// Callbacks to use to customize the behavior of the pretty-printer. 33class PrintingCallbacks { 34protected: 35 ~PrintingCallbacks() = default; 36 37public: 38 /// Remap a path to a form suitable for printing. 39 virtual std::string remapPath(StringRef Path) const { return Path; } 40}; 41 42/// Describes how types, statements, expressions, and declarations should be 43/// printed. 44/// 45/// This type is intended to be small and suitable for passing by value. 46/// It is very frequently copied. 47struct PrintingPolicy { 48 /// Create a default printing policy for the specified language. 49 PrintingPolicy(const LangOptions &LO) 50 : Indentation(2), SuppressSpecifiers(false), 51 SuppressTagKeyword(LO.CPlusPlus), IncludeTagDefinition(false), 52 SuppressScope(false), SuppressUnwrittenScope(false), 53 SuppressInitializers(false), ConstantArraySizeAsWritten(false), 54 AnonymousTagLocations(true), SuppressStrongLifetime(false), 55 SuppressLifetimeQualifiers(false), 56 SuppressTemplateArgsInCXXConstructors(false), Bool(LO.Bool), 57 Restrict(LO.C99), Alignof(LO.CPlusPlus11), UnderscoreAlignof(LO.C11), 58 UseVoidForZeroParams(!LO.CPlusPlus), TerseOutput(false), 59 PolishForDeclaration(false), Half(LO.Half), 60 MSWChar(LO.MicrosoftExt && !LO.WChar), IncludeNewlines(true), 61 MSVCFormatting(false), ConstantsAsWritten(false), 62 SuppressImplicitBase(false), FullyQualifiedName(false), 63 PrintCanonicalTypes(false) {} 64 65 /// Adjust this printing policy for cases where it's known that we're 66 /// printing C++ code (for instance, if AST dumping reaches a C++-only 67 /// construct). This should not be used if a real LangOptions object is 68 /// available. 69 void adjustForCPlusPlus() { 70 SuppressTagKeyword = true; 71 Bool = true; 72 UseVoidForZeroParams = false; 73 } 74 75 /// The number of spaces to use to indent each line. 76 unsigned Indentation : 8; 77 78 /// Whether we should suppress printing of the actual specifiers for 79 /// the given type or declaration. 80 /// 81 /// This flag is only used when we are printing declarators beyond 82 /// the first declarator within a declaration group. For example, given: 83 /// 84 /// \code 85 /// const int *x, *y; 86 /// \endcode 87 /// 88 /// SuppressSpecifiers will be false when printing the 89 /// declaration for "x", so that we will print "int *x"; it will be 90 /// \c true when we print "y", so that we suppress printing the 91 /// "const int" type specifier and instead only print the "*y". 92 unsigned SuppressSpecifiers : 1; 93 94 /// Whether type printing should skip printing the tag keyword. 95 /// 96 /// This is used when printing the inner type of elaborated types, 97 /// (as the tag keyword is part of the elaborated type): 98 /// 99 /// \code 100 /// struct Geometry::Point; 101 /// \endcode 102 unsigned SuppressTagKeyword : 1; 103 104 /// When true, include the body of a tag definition. 105 /// 106 /// This is used to place the definition of a struct 107 /// in the middle of another declaration as with: 108 /// 109 /// \code 110 /// typedef struct { int x, y; } Point; 111 /// \endcode 112 unsigned IncludeTagDefinition : 1; 113 114 /// Suppresses printing of scope specifiers. 115 unsigned SuppressScope : 1; 116 117 /// Suppress printing parts of scope specifiers that don't need 118 /// to be written, e.g., for inline or anonymous namespaces. 119 unsigned SuppressUnwrittenScope : 1; 120 121 /// Suppress printing of variable initializers. 122 /// 123 /// This flag is used when printing the loop variable in a for-range 124 /// statement. For example, given: 125 /// 126 /// \code 127 /// for (auto x : coll) 128 /// \endcode 129 /// 130 /// SuppressInitializers will be true when printing "auto x", so that the 131 /// internal initializer constructed for x will not be printed. 132 unsigned SuppressInitializers : 1; 133 134 /// Whether we should print the sizes of constant array expressions as written 135 /// in the sources. 136 /// 137 /// This flag determines whether array types declared as 138 /// 139 /// \code 140 /// int a[4+10*10]; 141 /// char a[] = "A string"; 142 /// \endcode 143 /// 144 /// will be printed as written or as follows: 145 /// 146 /// \code 147 /// int a[104]; 148 /// char a[9] = "A string"; 149 /// \endcode 150 unsigned ConstantArraySizeAsWritten : 1; 151 152 /// When printing an anonymous tag name, also print the location of that 153 /// entity (e.g., "enum <anonymous at t.h:10:5>"). Otherwise, just prints 154 /// "(anonymous)" for the name. 155 unsigned AnonymousTagLocations : 1; 156 157 /// When true, suppress printing of the __strong lifetime qualifier in ARC. 158 unsigned SuppressStrongLifetime : 1; 159 160 /// When true, suppress printing of lifetime qualifier in ARC. 161 unsigned SuppressLifetimeQualifiers : 1; 162 163 /// When true, suppresses printing template arguments in names of C++ 164 /// constructors. 165 unsigned SuppressTemplateArgsInCXXConstructors : 1; 166 167 /// Whether we can use 'bool' rather than '_Bool' (even if the language 168 /// doesn't actually have 'bool', because, e.g., it is defined as a macro). 169 unsigned Bool : 1; 170 171 /// Whether we can use 'restrict' rather than '__restrict'. 172 unsigned Restrict : 1; 173 174 /// Whether we can use 'alignof' rather than '__alignof'. 175 unsigned Alignof : 1; 176 177 /// Whether we can use '_Alignof' rather than '__alignof'. 178 unsigned UnderscoreAlignof : 1; 179 180 /// Whether we should use '(void)' rather than '()' for a function prototype 181 /// with zero parameters. 182 unsigned UseVoidForZeroParams : 1; 183 184 /// Provide a 'terse' output. 185 /// 186 /// For example, in this mode we don't print function bodies, class members, 187 /// declarations inside namespaces etc. Effectively, this should print 188 /// only the requested declaration. 189 unsigned TerseOutput : 1; 190 191 /// When true, do certain refinement needed for producing proper declaration 192 /// tag; such as, do not print attributes attached to the declaration. 193 /// 194 unsigned PolishForDeclaration : 1; 195 196 /// When true, print the half-precision floating-point type as 'half' 197 /// instead of '__fp16' 198 unsigned Half : 1; 199 200 /// When true, print the built-in wchar_t type as __wchar_t. For use in 201 /// Microsoft mode when wchar_t is not available. 202 unsigned MSWChar : 1; 203 204 /// When true, include newlines after statements like "break", etc. 205 unsigned IncludeNewlines : 1; 206 207 /// Use whitespace and punctuation like MSVC does. In particular, this prints 208 /// anonymous namespaces as `anonymous namespace' and does not insert spaces 209 /// after template arguments. 210 unsigned MSVCFormatting : 1; 211 212 /// Whether we should print the constant expressions as written in the 213 /// sources. 214 /// 215 /// This flag determines whether constants expressions like 216 /// 217 /// \code 218 /// 0x10 219 /// 2.5e3 220 /// \endcode 221 /// 222 /// will be printed as written or as follows: 223 /// 224 /// \code 225 /// 0x10 226 /// 2.5e3 227 /// \endcode 228 unsigned ConstantsAsWritten : 1; 229 230 /// When true, don't print the implicit 'self' or 'this' expressions. 231 unsigned SuppressImplicitBase : 1; 232 233 /// When true, print the fully qualified name of function declarations. 234 /// This is the opposite of SuppressScope and thus overrules it. 235 unsigned FullyQualifiedName : 1; 236 237 /// Whether to print types as written or canonically. 238 unsigned PrintCanonicalTypes : 1; 239 240 /// Callbacks to use to allow the behavior of printing to be customized. 241 const PrintingCallbacks *Callbacks = nullptr; 242}; 243 244} // end namespace clang 245 246#endif 247