1 files changed, 98 insertions, 64 deletions

diff --git a/utils/TableGen/LLDBOptionDefEmitter.cpp b/utils/TableGen/LLDBOptionDefEmitter.cpp
index 4e62197d3989..6e73d0c53de3 100644
--- a/utils/TableGen/LLDBOptionDefEmitter.cpp
+++ b/utils/TableGen/LLDBOptionDefEmitter.cpp
@@ -1,4 +1,4 @@
-//===- TableGen.cpp - Top-Level TableGen implementation for Clang ---------===//
+//===- LLDBOptionDefEmitter.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -12,140 +12,174 @@
 //===----------------------------------------------------------------------===//
 
 #include "LLDBTableGenBackends.h"
+#include "LLDBTableGenUtils.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/StringMatcher.h"
 #include "llvm/TableGen/TableGenBackend.h"
-#include <map>
 #include <vector>
 
 using namespace llvm;
+using namespace lldb_private;
 
-/// Map of command names to their associated records. Also makes sure our
-/// commands are sorted in a deterministic way.
-typedef std::map<std::string, std::vector<Record *>> RecordsByCommand;
-
-/// Groups all records by their command.
-static RecordsByCommand getCommandList(std::vector<Record *> Options) {
-  RecordsByCommand result;
-  for (Record *Option : Options)
-    result[Option->getValueAsString("Command").str()].push_back(Option);
-  return result;
-}
-
-static void emitOption(Record *Option, raw_ostream &OS) {
-  OS << "  {";
-
-  // List of option groups this option is in.
+namespace {
+struct CommandOption {
   std::vector<std::string> GroupsArg;
-
-  if (Option->getValue("Groups")) {
-    // The user specified a list of groups.
-    auto Groups = Option->getValueAsListOfInts("Groups");
-    for (int Group : Groups)
-      GroupsArg.push_back("LLDB_OPT_SET_" + std::to_string(Group));
-  } else if (Option->getValue("GroupStart")) {
-    // The user specified a range of groups (with potentially only one element).
-    int GroupStart = Option->getValueAsInt("GroupStart");
-    int GroupEnd = Option->getValueAsInt("GroupEnd");
-    for (int i = GroupStart; i <= GroupEnd; ++i)
-      GroupsArg.push_back("LLDB_OPT_SET_" + std::to_string(i));
+  bool Required = false;
+  std::string FullName;
+  std::string ShortName;
+  std::string ArgType;
+  bool OptionalArg = false;
+  std::string Validator;
+  std::string ArgEnum;
+  std::vector<StringRef> Completions;
+  std::string Description;
+
+  CommandOption() = default;
+  CommandOption(Record *Option) {
+    if (Option->getValue("Groups")) {
+      // The user specified a list of groups.
+      auto Groups = Option->getValueAsListOfInts("Groups");
+      for (int Group : Groups)
+        GroupsArg.push_back("LLDB_OPT_SET_" + std::to_string(Group));
+    } else if (Option->getValue("GroupStart")) {
+      // The user specified a range of groups (with potentially only one
+      // element).
+      int GroupStart = Option->getValueAsInt("GroupStart");
+      int GroupEnd = Option->getValueAsInt("GroupEnd");
+      for (int i = GroupStart; i <= GroupEnd; ++i)
+        GroupsArg.push_back("LLDB_OPT_SET_" + std::to_string(i));
+    }
+
+    // Check if this option is required.
+    Required = Option->getValue("Required");
+
+    // Add the full and short name for this option.
+    FullName = Option->getValueAsString("FullName");
+    ShortName = Option->getValueAsString("ShortName");
+
+    if (auto A = Option->getValue("ArgType"))
+      ArgType = A->getValue()->getAsUnquotedString();
+    OptionalArg = Option->getValue("OptionalArg") != nullptr;
+
+    if (Option->getValue("Validator"))
+      Validator = Option->getValueAsString("Validator");
+
+    if (Option->getValue("ArgEnum"))
+      ArgEnum = Option->getValueAsString("ArgEnum");
+
+    if (Option->getValue("Completions"))
+      Completions = Option->getValueAsListOfStrings("Completions");
+
+    if (auto D = Option->getValue("Description"))
+      Description = D->getValue()->getAsUnquotedString();
   }
+};
+} // namespace
+
+static void emitOption(const CommandOption &O, raw_ostream &OS) {
+  OS << "  {";
 
   // If we have any groups, we merge them. Otherwise we move this option into
   // the all group.
-  if (GroupsArg.empty())
+  if (O.GroupsArg.empty())
     OS << "LLDB_OPT_SET_ALL";
   else
-    OS << llvm::join(GroupsArg.begin(), GroupsArg.end(), " | ");
+    OS << llvm::join(O.GroupsArg.begin(), O.GroupsArg.end(), " | ");
 
   OS << ", ";
 
   // Check if this option is required.
-  OS << (Option->getValue("Required") ? "true" : "false");
+  OS << (O.Required ? "true" : "false");
 
   // Add the full and short name for this option.
-  OS << ", \"" << Option->getValueAsString("FullName") << "\", ";
-  OS << '\'' << Option->getValueAsString("ShortName") << "'";
-
-  auto ArgType = Option->getValue("ArgType");
-  bool IsOptionalArg = Option->getValue("OptionalArg") != nullptr;
+  OS << ", \"" << O.FullName << "\", ";
+  OS << '\'' << O.ShortName << "'";
 
   // Decide if we have either an option, required or no argument for this
   // option.
   OS << ", OptionParser::";
-  if (ArgType) {
-    if (IsOptionalArg)
+  if (!O.ArgType.empty()) {
+    if (O.OptionalArg)
       OS << "eOptionalArgument";
     else
       OS << "eRequiredArgument";
   } else
     OS << "eNoArgument";
-  OS << ", nullptr, ";
+  OS << ", ";
 
-  if (Option->getValue("ArgEnum"))
-    OS << Option->getValueAsString("ArgEnum");
+  if (!O.Validator.empty())
+    OS << O.Validator;
+  else
+    OS << "nullptr";
+  OS << ", ";
+
+  if (!O.ArgEnum.empty())
+    OS << O.ArgEnum;
   else
     OS << "{}";
   OS << ", ";
 
   // Read the tab completions we offer for this option (if there are any)
-  if (Option->getValue("Completions")) {
-    auto Completions = Option->getValueAsListOfStrings("Completions");
+  if (!O.Completions.empty()) {
     std::vector<std::string> CompletionArgs;
-    for (llvm::StringRef Completion : Completions)
+    for (llvm::StringRef Completion : O.Completions)
       CompletionArgs.push_back("CommandCompletions::e" + Completion.str() +
                                "Completion");
 
     OS << llvm::join(CompletionArgs.begin(), CompletionArgs.end(), " | ");
-  } else {
+  } else
     OS << "CommandCompletions::eNoCompletion";
-  }
 
   // Add the argument type.
   OS << ", eArgType";
-  if (ArgType) {
-    OS << ArgType->getValue()->getAsUnquotedString();
+  if (!O.ArgType.empty()) {
+    OS << O.ArgType;
   } else
     OS << "None";
   OS << ", ";
 
   // Add the description if there is any.
-  if (auto D = Option->getValue("Description"))
-    OS << D->getValue()->getAsString();
-  else
+  if (!O.Description.empty()) {
+    OS << "\"";
+    llvm::printEscapedString(O.Description, OS);
+    OS << "\"";
+  } else
     OS << "\"\"";
   OS << "},\n";
 }
 
 /// Emits all option initializers to the raw_ostream.
-static void emitOptions(std::string Command, std::vector<Record *> Option,
+static void emitOptions(std::string Command, std::vector<Record *> Records,
                         raw_ostream &OS) {
+  std::vector<CommandOption> Options;
+  for (Record *R : Records)
+    Options.emplace_back(R);
+
+  std::string ID = Command;
+  std::replace(ID.begin(), ID.end(), ' ', '_');
   // Generate the macro that the user needs to define before including the
   // *.inc file.
-  std::string NeededMacro = "LLDB_OPTIONS_" + Command;
-  std::replace(NeededMacro.begin(), NeededMacro.end(), ' ', '_');
+  std::string NeededMacro = "LLDB_OPTIONS_" + ID;
 
   // All options are in one file, so we need put them behind macros and ask the
   // user to define the macro for the options that are needed.
   OS << "// Options for " << Command << "\n";
   OS << "#ifdef " << NeededMacro << "\n";
-  for (Record *R : Option)
-    emitOption(R, OS);
+  OS << "constexpr static OptionDefinition g_" + ID + "_options[] = {\n";
+  for (CommandOption &CO : Options)
+    emitOption(CO, OS);
   // We undefine the macro for the user like Clang's include files are doing it.
+  OS << "};\n";
   OS << "#undef " << NeededMacro << "\n";
   OS << "#endif // " << Command << " command\n\n";
 }
 
 void lldb_private::EmitOptionDefs(RecordKeeper &Records, raw_ostream &OS) {
-
-  std::vector<Record *> Options = Records.getAllDerivedDefinitions("Option");
-
   emitSourceFileHeader("Options for LLDB command line commands.", OS);
 
-  RecordsByCommand ByCommand = getCommandList(Options);
-
-  for (auto &CommandRecordPair : ByCommand) {
+  std::vector<Record *> Options = Records.getAllDerivedDefinitions("Option");
+  for (auto &CommandRecordPair : getRecordsByName(Options, "Command")) {
     emitOptions(CommandRecordPair.first, CommandRecordPair.second, OS);
   }
 }