include/lldb/Core/FormatEntity.h

   1 //===-- FormatEntity.h ------------------------------------------*- 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 #ifndef liblldb_FormatEntity_h_
  11 #define liblldb_FormatEntity_h_
  12
  13 #include "lldb/Utility/FileSpec.h" // for FileSpec
  14 #include "lldb/Utility/Status.h"
  15 #include "lldb/lldb-enumerations.h" // for Format::eFormatDefault, Format
  16 #include "lldb/lldb-types.h"        // for addr_t
  17 #include <algorithm>                // for min
  18 #include <stddef.h>                 // for size_t
  19 #include <stdint.h>                 // for uint32_t, uint64_t
  20
  21 #include <string>
  22 #include <vector>
  23
  24 namespace lldb_private {
  25 class Address;
  26 }
  27 namespace lldb_private {
  28 class ExecutionContext;
  29 }
  30 namespace lldb_private {
  31 class Stream;
  32 }
  33 namespace lldb_private {
  34 class StringList;
  35 }
  36 namespace lldb_private {
  37 class SymbolContext;
  38 }
  39 namespace lldb_private {
  40 class ValueObject;
  41 }
  42 namespace llvm {
  43 class StringRef;
  44 }
  45
  46 namespace lldb_private {
  47 class FormatEntity {
  48 public:
  49   struct Entry {
  50     enum class Type {
  51       Invalid,
  52       ParentNumber,
  53       ParentString,
  54       InsertString,
  55       Root,
  56       String,
  57       Scope,
  58       Variable,
  59       VariableSynthetic,
  60       ScriptVariable,
  61       ScriptVariableSynthetic,
  62       AddressLoad,
  63       AddressFile,
  64       AddressLoadOrFile,
  65       ProcessID,
  66       ProcessFile,
  67       ScriptProcess,
  68       ThreadID,
  69       ThreadProtocolID,
  70       ThreadIndexID,
  71       ThreadName,
  72       ThreadQueue,
  73       ThreadStopReason,
  74       ThreadReturnValue,
  75       ThreadCompletedExpression,
  76       ScriptThread,
  77       ThreadInfo,
  78       TargetArch,
  79       ScriptTarget,
  80       ModuleFile,
  81       File,
  82       Lang,
  83       FrameIndex,
  84       FrameNoDebug,
  85       FrameRegisterPC,
  86       FrameRegisterSP,
  87       FrameRegisterFP,
  88       FrameRegisterFlags,
  89       FrameRegisterByName,
  90       ScriptFrame,
  91       FunctionID,
  92       FunctionDidChange,
  93       FunctionInitialFunction,
  94       FunctionName,
  95       FunctionNameWithArgs,
  96       FunctionNameNoArgs,
  97       FunctionAddrOffset,
  98       FunctionAddrOffsetConcrete,
  99       FunctionLineOffset,
 100       FunctionPCOffset,
 101       FunctionInitial,
 102       FunctionChanged,
 103       FunctionIsOptimized,
 104       LineEntryFile,
 105       LineEntryLineNumber,
 106       LineEntryStartAddress,
 107       LineEntryEndAddress,
 108       CurrentPCArrow
 109     };
 110
 111     enum FormatType { None, UInt32, UInt64, CString };
 112
 113     struct Definition {
 114       const char *name;
 115       const char *string; // Insert this exact string into the output
 116       Entry::Type type;
 117       FormatType format_type; // uint32_t, uint64_t, cstr, or anything that can
 118                               // be formatted by printf or lldb::Format
 119       uint64_t data;
 120       uint32_t num_children;
 121       Definition *children; // An array of "num_children" Definition entries,
 122       bool keep_separator;
 123     };
 124
 125     Entry(Type t = Type::Invalid, const char *s = nullptr,
 126           const char *f = nullptr)
 127         : string(s ? s : ""), printf_format(f ? f : ""), children(),
 128           definition(nullptr), type(t), fmt(lldb::eFormatDefault), number(0),
 129           deref(false) {}
 130
 131     Entry(llvm::StringRef s);
 132     Entry(char ch);
 133
 134     void AppendChar(char ch);
 135
 136     void AppendText(const llvm::StringRef &s);
 137
 138     void AppendText(const char *cstr);
 139
 140     void AppendEntry(const Entry &&entry) { children.push_back(entry); }
 141
 142     void Clear() {
 143       string.clear();
 144       printf_format.clear();
 145       children.clear();
 146       definition = nullptr;
 147       type = Type::Invalid;
 148       fmt = lldb::eFormatDefault;
 149       number = 0;
 150       deref = false;
 151     }
 152
 153     static const char *TypeToCString(Type t);
 154
 155     void Dump(Stream &s, int depth = 0) const;
 156
 157     bool operator==(const Entry &rhs) const {
 158       if (string != rhs.string)
 159         return false;
 160       if (printf_format != rhs.printf_format)
 161         return false;
 162       const size_t n = children.size();
 163       const size_t m = rhs.children.size();
 164       for (size_t i = 0; i < std::min<size_t>(n, m); ++i) {
 165         if (!(children[i] == rhs.children[i]))
 166           return false;
 167       }
 168       if (children != rhs.children)
 169         return false;
 170       if (definition != rhs.definition)
 171         return false;
 172       if (type != rhs.type)
 173         return false;
 174       if (fmt != rhs.fmt)
 175         return false;
 176       if (deref != rhs.deref)
 177         return false;
 178       return true;
 179     }
 180
 181     std::string string;
 182     std::string printf_format;
 183     std::vector<Entry> children;
 184     Definition *definition;
 185     Type type;
 186     lldb::Format fmt;
 187     lldb::addr_t number;
 188     bool deref;
 189   };
 190
 191   static bool Format(const Entry &entry, Stream &s, const SymbolContext *sc,
 192                      const ExecutionContext *exe_ctx, const Address *addr,
 193                      ValueObject *valobj, bool function_changed,
 194                      bool initial_function);
 195
 196   static bool FormatStringRef(const llvm::StringRef &format, Stream &s,
 197                               const SymbolContext *sc,
 198                               const ExecutionContext *exe_ctx,
 199                               const Address *addr, ValueObject *valobj,
 200                               bool function_changed, bool initial_function);
 201
 202   static bool FormatCString(const char *format, Stream &s,
 203                             const SymbolContext *sc,
 204                             const ExecutionContext *exe_ctx,
 205                             const Address *addr, ValueObject *valobj,
 206                             bool function_changed, bool initial_function);
 207
 208   static Status Parse(const llvm::StringRef &format, Entry &entry);
 209
 210   static Status ExtractVariableInfo(llvm::StringRef &format_str,
 211                                     llvm::StringRef &variable_name,
 212                                     llvm::StringRef &variable_format);
 213
 214   static size_t AutoComplete(llvm::StringRef s, int match_start_point,
 215                              int max_return_elements, bool &word_complete,
 216                              StringList &matches);
 217
 218   //----------------------------------------------------------------------
 219   // Format the current elements into the stream \a s.
 220   //
 221   // The root element will be stripped off and the format str passed in
 222   // will be either an empty string (print a description of this object),
 223   // or contain a . separated series like a domain name that identifies
 224   // further sub elements to display.
 225   //----------------------------------------------------------------------
 226   static bool FormatFileSpec(const FileSpec &file, Stream &s,
 227                              llvm::StringRef elements,
 228                              llvm::StringRef element_format);
 229
 230 protected:
 231   static Status ParseInternal(llvm::StringRef &format, Entry &parent_entry,
 232                               uint32_t depth);
 233 };
 234 } // namespace lldb_private
 235
 236 #endif // liblldb_FormatEntity_h_