Also adding OutputEventHandler to add another type that has more complex usage.

Directly setting the event handlers on the DAP object and using the previous naming convention of 'Send<event>' instead of 'on<event>'.

Author: ashgti

lldb/tools/lldb-dap/CMakeLists.txt

@@ -39,6 +39,7 @@ add_lldb_tool(lldb-dap
 
   Events/ExitedEventHandler.cpp
   Events/ProcessEventHandler.cpp
+  Events/OutputEventHandler.cpp
 
   Handler/ResponseHandler.cpp
   Handler/AttachRequestHandler.cpp

lldb/tools/lldb-dap/DAP.cpp

@@ -83,9 +83,8 @@ DAP::DAP(llvm::StringRef path, std::ofstream *log,
       configuration_done_sent(false), waiting_for_run_in_terminal(false),
       progress_event_reporter(
           [&](const ProgressEvent &event) { SendJSON(event.ToJSON()); }),
-      reverse_request_seq(0), repl_mode(default_repl_mode),
-      onExited(ExitedEventHandler(*this)),
-      onProcess(ProcessEventHandler(*this)) {}
+      reverse_request_seq(0), repl_mode(default_repl_mode), SendExited(*this),
+      SendProcess(*this), SendOutput(*this) {}
 
 DAP::~DAP() = default;
 
@@ -205,12 +204,12 @@ llvm::Error DAP::ConfigureIO(std::FILE *overrideOut, std::FILE *overrideErr) {
   in = lldb::SBFile(std::fopen(DEV_NULL, "r"), /*transfer_ownership=*/true);
 
   if (auto Error = out.RedirectTo(overrideOut, [this](llvm::StringRef output) {
-        SendOutput(OutputType::Stdout, output);
+        SendOutput(output, OutputCategory::Stdout);
       }))
     return Error;
 
   if (auto Error = err.RedirectTo(overrideErr, [this](llvm::StringRef output) {
-        SendOutput(OutputType::Stderr, output);
+        SendOutput(output, OutputCategory::Stderr);
       }))
     return Error;
 
@@ -249,103 +248,6 @@ void DAP::Send(const protocol::Message &message) {
                   transport.GetClientName());
 }
 
-// "OutputEvent": {
-//   "allOf": [ { "$ref": "#/definitions/Event" }, {
-//     "type": "object",
-//     "description": "Event message for 'output' event type. The event
-//                     indicates that the target has produced some output.",
-//     "properties": {
-//       "event": {
-//         "type": "string",
-//         "enum": [ "output" ]
-//       },
-//       "body": {
-//         "type": "object",
-//         "properties": {
-//           "category": {
-//             "type": "string",
-//             "description": "The output category. If not specified,
-//                             'console' is assumed.",
-//             "_enum": [ "console", "stdout", "stderr", "telemetry" ]
-//           },
-//           "output": {
-//             "type": "string",
-//             "description": "The output to report."
-//           },
-//           "variablesReference": {
-//             "type": "number",
-//             "description": "If an attribute 'variablesReference' exists
-//                             and its value is > 0, the output contains
-//                             objects which can be retrieved by passing
-//                             variablesReference to the VariablesRequest."
-//           },
-//           "source": {
-//             "$ref": "#/definitions/Source",
-//             "description": "An optional source location where the output
-//                             was produced."
-//           },
-//           "line": {
-//             "type": "integer",
-//             "description": "An optional source location line where the
-//                             output was produced."
-//           },
-//           "column": {
-//             "type": "integer",
-//             "description": "An optional source location column where the
-//                             output was produced."
-//           },
-//           "data": {
-//             "type":["array","boolean","integer","null","number","object",
-//                     "string"],
-//             "description": "Optional data to report. For the 'telemetry'
-//                             category the data will be sent to telemetry, for
-//                             the other categories the data is shown in JSON
-//                             format."
-//           }
-//         },
-//         "required": ["output"]
-//       }
-//     },
-//     "required": [ "event", "body" ]
-//   }]
-// }
-void DAP::SendOutput(OutputType o, const llvm::StringRef output) {
-  if (output.empty())
-    return;
-
-  const char *category = nullptr;
-  switch (o) {
-  case OutputType::Console:
-    category = "console";
-    break;
-  case OutputType::Stdout:
-    category = "stdout";
-    break;
-  case OutputType::Stderr:
-    category = "stderr";
-    break;
-  case OutputType::Telemetry:
-    category = "telemetry";
-    break;
-  }
-
-  // Send each line of output as an individual event, including the newline if
-  // present.
-  ::size_t idx = 0;
-  do {
-    ::size_t end = output.find('\n', idx);
-    if (end == llvm::StringRef::npos)
-      end = output.size() - 1;
-    llvm::json::Object event(CreateEventObject("output"));
-    llvm::json::Object body;
-    body.try_emplace("category", category);
-    EmplaceSafeString(body, "output", output.slice(idx, end + 1).str());
-    event.try_emplace("body", std::move(body));
-    SendJSON(llvm::json::Value(std::move(event)));
-    idx = end + 1;
-  } while (idx < output.size());
-}
-
 // interface ProgressStartEvent extends Event {
 //   event: 'progressStart';
 //
@@ -444,16 +346,17 @@ void DAP::SendProgressEvent(uint64_t progress_id, const char *message,
   progress_event_reporter.Push(progress_id, message, completed, total);
 }
 
-void __attribute__((format(printf, 3, 4)))
-DAP::SendFormattedOutput(OutputType o, const char *format, ...) {
-  char buffer[1024];
-  va_list args;
-  va_start(args, format);
-  int actual_length = vsnprintf(buffer, sizeof(buffer), format, args);
-  va_end(args);
-  SendOutput(
-      o, llvm::StringRef(buffer, std::min<int>(actual_length, sizeof(buffer))));
-}
+// void __attribute__((format(printf, 3, 4)))
+// DAP::SendFormattedOutput(OutputType o, const char *format, ...) {
+//   char buffer[1024];
+//   va_list args;
+//   va_start(args, format);
+//   int actual_length = vsnprintf(buffer, sizeof(buffer), format, args);
+//   va_end(args);
+//   SendOutput(
+//       o, llvm::StringRef(buffer, std::min<int>(actual_length,
+//       sizeof(buffer))));
+// }
 
 ExceptionBreakpoint *DAP::GetExceptionBPFromStopReason(lldb::SBThread &thread) {
   const auto num = thread.GetStopReasonDataCount();
@@ -567,7 +470,7 @@ bool DAP::RunLLDBCommands(llvm::StringRef prefix,
   bool required_command_failed = false;
   std::string output =
       ::RunLLDBCommands(debugger, prefix, commands, required_command_failed);
-  SendOutput(OutputType::Console, output);
+  SendOutput(output);
   return !required_command_failed;
 }
 
@@ -1044,8 +947,7 @@ void DAP::SetFrameFormat(llvm::StringRef format) {
   lldb::SBError error;
   frame_format = lldb::SBFormat(format.str().c_str(), error);
   if (error.Fail()) {
-    SendOutput(OutputType::Console,
-               llvm::formatv(
+    SendOutput(llvm::formatv(
                    "The provided frame format '{0}' couldn't be parsed: {1}\n",
                    format, error.GetCString())
                    .str());
@@ -1058,8 +960,7 @@ void DAP::SetThreadFormat(llvm::StringRef format) {
   lldb::SBError error;
   thread_format = lldb::SBFormat(format.str().c_str(), error);
   if (error.Fail()) {
-    SendOutput(OutputType::Console,
-               llvm::formatv(
+    SendOutput(llvm::formatv(
                    "The provided thread format '{0}' couldn't be parsed: {1}\n",
                    format, error.GetCString())
                    .str());

lldb/tools/lldb-dap/DAP.h

@@ -10,6 +10,7 @@
 #define LLDB_TOOLS_LLDB_DAP_DAP_H
 
 #include "DAPForward.h"
+#include "Events/EventHandler.h"
 #include "ExceptionBreakpoint.h"
 #include "FunctionBreakpoint.h"
 #include "InstructionBreakpoint.h"
@@ -58,11 +59,6 @@ typedef llvm::StringMap<FunctionBreakpoint> FunctionBreakpointMap;
 typedef llvm::DenseMap<lldb::addr_t, InstructionBreakpoint>
     InstructionBreakpointMap;
 
-/// A debug adapter initiated event.
-template <typename... Args> using OutgoingEvent = std::function<void(Args...)>;
-
-enum class OutputType { Console, Stdout, Stderr, Telemetry };
-
 /// Buffer size for handling output events.
 constexpr uint64_t OutputBufferSize = (1u << 12);
 
@@ -236,11 +232,13 @@ struct DAP {
   /// Typed Events Handlers
   /// @{
 
-  /// onExited sends an event that the debuggee has exited.
-  OutgoingEvent<> onExited;
-  /// onProcess sends an event that indicates that the debugger has begun
-  /// debugging a new process.
-  OutgoingEvent<> onProcess;
+  /// Sends an event that the debuggee has exited.
+  ExitedEventHandler SendExited;
+  /// Sends an event that indicates that the debugger has begun debugging a new
+  /// process.
+  ProcessEventHandler SendProcess;
+  /// Sends an event that indicates the target has produced some output.
+  OutputEventHandler SendOutput;
 
   /// @}
 
@@ -263,14 +261,9 @@ struct DAP {
   /// Send the given message to the client
   void Send(const protocol::Message &message);
 
-  void SendOutput(OutputType o, const llvm::StringRef output);
-
   void SendProgressEvent(uint64_t progress_id, const char *message,
                          uint64_t completed, uint64_t total);
 
-  void __attribute__((format(printf, 3, 4)))
-  SendFormattedOutput(OutputType o, const char *format, ...);
-
   static int64_t GetNextSourceReference();
 
   ExceptionBreakpoint *GetExceptionBPFromStopReason(lldb::SBThread &thread);

lldb/tools/lldb-dap/EventHelper.cpp

@@ -8,6 +8,7 @@
 
 #include "EventHelper.h"
 #include "DAP.h"
+#include "Events/EventHandler.h"
 #include "JSONUtils.h"
 #include "LLDBUtils.h"
 #include "lldb/API/SBFileSpec.h"
@@ -128,9 +129,9 @@ void SendStdOutStdErr(DAP &dap, lldb::SBProcess &process) {
   char buffer[OutputBufferSize];
   size_t count;
   while ((count = process.GetSTDOUT(buffer, sizeof(buffer))) > 0)
-    dap.SendOutput(OutputType::Stdout, llvm::StringRef(buffer, count));
+    dap.SendOutput(llvm::StringRef(buffer, count), OutputCategory::Stdout);
   while ((count = process.GetSTDERR(buffer, sizeof(buffer))) > 0)
-    dap.SendOutput(OutputType::Stderr, llvm::StringRef(buffer, count));
+    dap.SendOutput(llvm::StringRef(buffer, count), OutputCategory::Stderr);
 }
 
 // Send a "continued" event to indicate the process is in the running state.

lldb/tools/lldb-dap/Events/EventHandler.h

@@ -9,47 +9,51 @@
 #ifndef LLDB_TOOLS_LLDB_DAP_EVENTS_EVENT_HANDLER
 #define LLDB_TOOLS_LLDB_DAP_EVENTS_EVENT_HANDLER
 
-#include "DAP.h"
-#include "Protocol/ProtocolBase.h"
+#include "DAPForward.h"
 #include "Protocol/ProtocolEvents.h"
-#include "lldb/API/SBProcess.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace lldb_dap {
 
-template <typename Body, typename... Args> class BaseEventHandler {
+/// An event handler for triggering DAP events.
+class EventHandler {
 public:
-  BaseEventHandler(DAP &dap) : dap(dap) {}
-
-  virtual ~BaseEventHandler() = default;
-
-  virtual llvm::StringLiteral getEvent() const = 0;
-  virtual Body Handler(Args...) const = 0;
-
-  void operator()(Args... args) const {
-    Body body = Handler(args...);
-    protocol::Event event{/*event=*/getEvent().str(), /*body=*/std::move(body)};
-    dap.Send(event);
-  }
+  EventHandler(DAP &dap) : dap(dap) {}
+  virtual ~EventHandler() = default;
 
 protected:
   DAP &dap;
 };
 
 /// Handler for the event indicates that the debuggee has exited and returns its
 /// exit code.
-class ExitedEventHandler : public BaseEventHandler<protocol::ExitedEventBody> {
+class ExitedEventHandler : public EventHandler {
+public:
+  using EventHandler::EventHandler;
+  static constexpr llvm::StringLiteral event = "exited";
+  void operator()(lldb::SBProcess &process) const;
+};
+
+using ProcessStartMethod = protocol::ProcessEventBody::StartMethod;
+
+/// Handler for the event indicates that the debugger has begun debugging a new
+/// process. Either one that it has launched, or one that it has attached to.
+class ProcessEventHandler : public EventHandler {
 public:
-  using BaseEventHandler::BaseEventHandler;
-  llvm::StringLiteral getEvent() const override { return "exited"; }
-  protocol::ExitedEventBody Handler() const override;
+  using EventHandler::EventHandler;
+  static constexpr llvm::StringLiteral event = "process";
+  void operator()(lldb::SBTarget &target, ProcessStartMethod startMethod) const;
 };
 
-class ProcessEventHandler
-    : public BaseEventHandler<protocol::ProcessEventBody> {
+using OutputCategory = protocol::OutputEventBody::Category;
+
+/// Handle for the event indicates that the target has produced some output.
+class OutputEventHandler : public EventHandler {
 public:
-  using BaseEventHandler::BaseEventHandler;
-  llvm::StringLiteral getEvent() const override { return "process"; }
-  protocol::ProcessEventBody Handler() const override;
+  using EventHandler::EventHandler;
+  static constexpr llvm::StringLiteral event = "output";
+  void operator()(llvm::StringRef output,
+                  OutputCategory category = OutputCategory::Console) const;
 };
 
 } // end namespace lldb_dap

lldb/tools/lldb-dap/Events/ExitedEventHandler.cpp

@@ -6,15 +6,20 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "DAP.h"
 #include "Events/EventHandler.h"
 #include "lldb/API/SBProcess.h"
 
 namespace lldb_dap {
 
-protocol::ExitedEventBody ExitedEventHandler::Handler() const {
+void ExitedEventHandler::operator()(lldb::SBProcess &process) const {
+  if (!process.IsValid())
+    return;
+
   protocol::ExitedEventBody body;
-  body.exitCode = dap.target.GetProcess().GetExitStatus();
-  return body;
+  body.exitCode = process.GetExitStatus();
+  dap.Send(protocol::Event{/*event=*/ExitedEventHandler::event.str(),
+                           /*body=*/std::move(body)});
 }
 
 } // namespace lldb_dap