Enable Launching the Debugee in VSCode Terminal

[wallace]

Summary

A "Launch In Terminal" option is added to the debug settings in IDE. When turn this option on, the debugee will be launched inside the integrated terminal so that user can input values for debugging. This diff involves the runInTerminal request sent from lldb to IDE and lldb won't attach the program until the runInTerminal response is received. A response handler for the runInTerminal response from IDE to lldb is added to handle the reverse requests and corresponding responses.
The screenshot shows what it looks like when the debugee is launched in terminal.

[wallace]

This is very good for a first implementation. You need to write a test for this as well. Once this works, you have to work on the launcher helper Greg and I mentioned to you that will help you guarantee you can always attach to the target.

Regarding the test, you have to build the python code that will mimic the runInTerminal reverse request, along with its response, which will just launch the debuggee inside a terminal.

For launching a process inside a shell from python, you can use the subprocess.run function and pass the shell=True attribute.

For adding the runInTerminal reverse request in python, take a look at the file packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py. You can see examples like request_launch, where it sends data and waits for a response using the send_recv method. You should add support for reverse requests.

lldb/tools/lldb-vscode/lldb-vscode.cpp

1377

s/VScode/VSCode

1582–1584

move the entire contents of this if to another function for readability

1586

does it work if you don't specify the "seq" number? If it works without it, I would leave it empty

1589

what if cwd is not specified in the arguments? I imagine this might break or at least the IDE wouldn't be able to launch the target properly.
If "cwd" is not defined, then use llvm::sys::fs::current_path() instead. Does this make sense @clayborg ?

1590

mention here that VSCode doesn't respond back the pid of the target, so we can only attach by process name, which is already set up in the request_launch method

1595–1598

run clang-format

1602

remove this comment

1602

shouldn't you return at this point and not execute anything that happens after this?
The lines

g_vsc.SendJSON(llvm::json::Value(std::move(response)));
SendProcessEvent(Launch); // Maybe change this for Attach as you'll end up actually doing an attach
g_vsc.SendJSON(llvm::json::Value(CreateEventObject("initialized")));

probably should only be sent after you were able to attach.

1633–1634

what happens if it fails to attach? Try running a program that dies right away and that lldb can't attach. Does the debug session terminate correctly?

1642

remove this

3029

you should use the command here, instead of the hardcoded string "runInTerminal"

[clayborg]

So there is a fundamental change needed for this patch to work. I tried to fully detail this in the inline comments. Let me know if you have any questions.

lldb/tools/lldb-vscode/lldb-vscode.cpp

1586

Remove this line. I will explain more in next inline comment!

1589

yes, we need to set this correctly if it isn't set in the launch.json and your suggestion makes sense.

1601

So I am not sure we need to do all of the response handler stuff since we need to get the result of this before we can proceed. So we need to be able to send this request and receive the response right here. So we need to add that ability to VSCode (the type definition of g_vsc).

This code should be:

llvm::json::Object reverseResponse = g_vsc.SendReverseRequest(llvm::json::Value(std::move(reverseRequest)));

Then we need to extract the pid from the response right in this function. Right now we don't have a thread that is listening for more packets, we just have the main thread getting the current packet ("launch" in this case) and we are currently handling this function, so there is no way we will get a response in this function if we don't do this.

You will need to write the "SendReverseRequest()" function in VSCode and it will rely on refactoring that I mentioned below in the main() function where we make VSCode::GetObject() and VSCode::HandleObject() and uses the new "PacketStatus" enum. The SendReverseRequest function will do something like:

struct VSCode {
...
  uint32_t reverse_request_seq = 0;  
  PacketStatus SendReverseRequest(const llvm::json::Value &request, llvm::json::Object &response) {
    // Put the right "seq" into the packet here, so we don't have to do it from
    // where we send the reverse request.
    request.try_emplace("seq", ++reverse_request_seq);
    SendJSON(request);
    bool got_response = false;
    while (!got_response) {
      llvm::json::Object response;
      Status status = GetObject(response);
      if (status == PacketStatus::Success) {
        const auto packet_type = GetString(response, "type");
        if (packet_type == "response")
          return status;
        // Not our response, we got another packet
       HandleObject(response)
      } else {
        return status;
      }
    }
  }

The "VSCode::GetResponse" is a new function as well that we will make from

3016–3026

We need to move these lines into VSCode.h and VSCode.cpp into a function called GetObject():

enum class PacketStatus {
  Success = 0
  EndOfFile,
  JSONMalformed,
  JSONNotObject
};

PacketStatus VSCode::GetObject(llvm::json::Object &object) {
  std::string json =ReadJSON();
  if (json.empty())
      return PacketStatus::EndOfFile;

  llvm::StringRef json_sref(json);
  llvm::Expected<llvm::json::Value> json_value = llvm::json::parse(json_sref);
  if (!json_value) {
    auto error = json_value.takeError();
    if (log) {
      std::string error_str;
      llvm::raw_string_ostream strm(error_str);
      strm << error;
      strm.flush();
      *log << "error: failed to parse JSON: " << error_str << std::endl
                 << json << std::endl;
    }
    return PacketStatus::JSONMalformed;
  }
  object = std::move(json_value->getAsObject());
  if (!object) {
    if (log)
      *log << "error: json packet isn't a object" << std::endl;
    return PacketStatus::JSONNotObject;
  }
  return PacketStatus::Success;
}

This will allow us to use this function in the VSCode::SendReverseRequest(). Then this code becomes:

llvm::json::Object object;
PacketStatus status = g_vsc.GetObject(object);
if (status == PacketStatus::EndOfFile)
  break;
if (status != PacketStatus::Success)
  return 1; // Fatal error

We need to do this so we can re-use the VSCode::GetObject in VSCode::SendReverseRequest().

3025–3026

This should also be moved into VSCode.h/VSCode.cpp:

bool VSCode::HandleObject(const llvm::json::Object& object) {

const auto packet_type = GetString(object, "type");
if (packet_type == "request") {
  const auto command = GetString(object, "command");
  auto handler_pos = request_handlers.find(std::string(command));
  if (handler_pos != request_handlers.end()) {
    handler_pos->second(*object);
    return true; // Success
} else {
    if (log)
      *log << "error: unhandled command \"" << command.data() << std::endl;
    return false; // Fail
}

}

Then this code becomes:

if (!g_vsc.HandleObject(object))

return 1;

[clayborg]

lldb/tools/lldb-vscode/lldb-vscode.cpp

1590

The response has the process ID of what we need to attach to right? Why do we need to do this by name?

[• aelitashen]

Add a attacher thread to avoid race condition

[• aelitashen]

Remove uncomplete tests

[clayborg]

So there is a lot of noise in this patch that is just reformatting on code that hasn't changed. It would be nice to get rid of any changes that are whitespace/indentation/formatting only. Also see inlined comments for needed changes.

lldb/tools/lldb-vscode/VSCode.cpp

410

add "const" to before "llvm::json::Object &request"

lldb/tools/lldb-vscode/VSCode.h

166–173

Revert all changes to this function. Seems like there are some forward declarations to functions in here for some reason that aren't needed.

lldb/tools/lldb-vscode/lldb-vscode.cpp

1441

Add more comment here to explain how we are attaching. Maybe something like:

// We have already created a target that has a valid "program" path to the executable.
// We will attach to the next process whose basename matches that of the target's 
// executable by waiting for the next process to launch that matches. This help LLDB
// ignore any existing processes that are already running that match this executable
// name and wait for the next one to launch.

1448–1449

Inline the lambda, add a comment, and enable async mode to ensure we don't have a race condition:

// Here we launch a thread to do the attach. We disable async events so
// that when we call g_vsc.target.Attach(...) it will not return unless the attach
// succeeds. In the event the attach never happens, the user will be able to hit
// the square stop button in the debug session and it will kill lldb-vscode. If
// this ever changes in the IDE we will need to do more work to ensure we can
// nicely timeout from the attach after a set period of time.
std::thread attacher([&]() { 
   g_vsc.debugger.SetAsync(false);
   g_vsc.target.Attach(attach_info, error); 
   g_vsc.debugger.SetAsync(true);
});

1486–1506

Need to clean up this logic a bit. We have two "if (error.Success())" statements and the flow of the code is hard to follow.

if (error.Success()) {
  // IDE doesn't respond back the pid of the target from the runInTerminal 
  // response, so we have lldb attach by name and wait, so grab the process
  // ID from the target.
  auto attached_pid = g_vsc.target.GetProcess().GetProcessID();
  if (attached_pid == LLDB_INVALID_PROCESS_ID)
    error.SetErrorString("Failed to attach to a process");
  else
    SendProcessEvent(Attach);
}

// Check error again as it might have been modified with a new error above.
if (error.Fail()) {
  launch_response["success"] = llvm::json::Value(false);
  EmplaceSafeString(launch_response, "message", std::string(error.GetCString()));
} else {
  launch_response["success"] = llvm::json::Value(true);
}

1582–1585

Remove all new indentation that was added for the else scope and use early return:

if (GetBoolean(arguments, "launchInTerminal", false)) {
  request_runInTerminal(request, response);
  g_vsc.SendJSON(llvm::json::Value(std::move(response)));
  return;
}

[clayborg]

lldb/tools/lldb-vscode/VSCode.h

173

I thought this was the contents of a "lldb::SBTarget CreateTargetFromArguments(const llvm::json::Object &arguments, lldb::SBError &error);" function!

Ignore this bad comment!

[clayborg]

lldb/tools/lldb-vscode/VSCode.cpp

410

I see we are modifying "request" below, so we can't make it "const". There are two ways to fix this:
1 - change it to be "llvm::json::Object request" and then use std::move() when calling SendReverseRequest.
2 - just leave as a reference and modify the original object.

I think I prefer option #1.

[clayborg]

lldb/tools/lldb-vscode/VSCode.cpp

410

Or we can leave this as "const" as originally suggested and add a function to VSCode:

llvm::json::Object VSCode::CreateReverseRequest(std::string command) {
  llvm::json::Object request;
  request.try_emplace("type", "request");
  request.try_emplace("command", command);
  request.try_emplace("seq", ++reverse_request_seq);
  return request;
}

And call that in request_runInTerminal when creating the reverse request packet. See other inline comment for details.

lldb/tools/lldb-vscode/lldb-vscode.cpp

1453–1455

This could become:

llvm::json::Object reverseRequest = g_vsc.CreateReverseRequest("runInTerminal");

And then we wouldn't need to add the "seq" key/value pair in SendReverseRequest

[• aelitashen]

Refactor code and optimize logic

[• aelitashen]

I tried rebase onto the commit that Walter created just for formatting but I am not sure why it didn't remove those formatting noise..

lldb/tools/lldb-vscode/VSCode.cpp

410

I eventually choose #1 cuz const keeps raising problem when calling function like try_emplace() and move() :(

[clayborg]

All of the code looks good now and we need to add a test. This means we will need to modify vscode.py in the test suite to be able to received the reverse request and just launch the process. We don't need to launch the program in a terminal, just spawn the process using subprocess.

[• aelitashen]

@Walter Please help me fix the tests. Looks like in the new added runInTerminal tests, it cannot hit the breakpoint and capture the local variable.

[wallace]

We found a very strange issue with lldb not stopping at any breakpoint after attaching. I'll figure that out

[wallace]

Now this feature is fully functional. Besiding adding a test, I was able to debug LLDB from an integrated terminal in VSCode. Stdin and stdout work correctly.

This is LLDB being debugger

Regarding the implementation, I'm attaching asynchronously to the inferior using the wait-for logic. As soon as the first stop event happens, the response from the launch request is sent to the IDE to finish the configuration.

As a last detail, when the debug session ends, VSCode closes the terminal.

[aeubanks]

the added test TestVSCode_runInTerminal consistently fails for me locally with

Failed to attach to the target process. Timed out trying to get messages from the runInTerminal launcher

I've asked other people and they've also reported consistent (or flaky) failures of this test. Any idea of what could be going wrong?

[labath]

I'm pretty sure that's because YAMA prevents the attach operation. The test probably needs to launch the binary through something like this.

lldb/tools/lldb-vscode/VSCode.h

 #include <set>
 #include <stdio.h>
 #include <thread>
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "lldb/API/SBAttachInfo.h"
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBCommunication.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBHostOS.h"

 #define VARIDX_TO_VARREF(i) ((i) + VARREF_FIRST_VAR_IDX)
 #define VARREF_TO_VARIDX(v) ((v)-VARREF_FIRST_VAR_IDX)
 #define NO_TYPENAME "<no-type>"
 
 namespace lldb_vscode {
 
 typedef llvm::DenseMap<uint32_t, SourceBreakpoint> SourceBreakpointMap;
 typedef llvm::StringMap<FunctionBreakpoint> FunctionBreakpointMap;
+typedef void (*RequestCallback)(const llvm::json::Object &command);
 enum class OutputType { Console, Stdout, Stderr, Telemetry };
 
 enum VSCodeBroadcasterBits { eBroadcastBitStopEventThread = 1u << 0 };
 
 struct VSCode {
   InputStream input;
   OutputStream output;
   lldb::SBDebugger debugger;
struct VSCode {
   std::vector<std::string> pre_run_commands;
   std::vector<std::string> exit_commands;
   std::vector<std::string> stop_commands;
   std::vector<std::string> terminate_commands;
   lldb::tid_t focus_tid;
   bool sent_terminated_event;
   bool stop_at_entry;
   bool is_attach;
+  uint32_t reverse_request_seq = 0;
+  enum class PacketStatus {
+    Success = 0,
+    EndOfFile,
+    JSONMalformed,
+    JSONNotObject
+  };
+  std::map<std::string, RequestCallback> m_request_handlers;
   // Keep track of the last stop thread index IDs as threads won't go away
   // unless we send a "thread" event to indicate the thread exited.
   llvm::DenseSet<lldb::tid_t> thread_ids;
   VSCode();
   ~VSCode();
   VSCode(const VSCode &rhs) = delete;
   void operator=(const VSCode &rhs) = delete;
   int64_t GetLineForPC(int64_t sourceReference, lldb::addr_t pc) const;
struct VSCode {
   ///     Launch configuration arguments.
   ///
   /// \param[out] error
   ///     An SBError object that will contain an error description if
   ///     function failed to create the target.
   ///
   /// \return
   ///     An SBTarget object.
-  lldb::SBTarget CreateTargetFromArguments(
-      const llvm::json::Object &arguments,
+  lldb::SBTarget CreateTargetFromArguments(const llvm::json::Object &arguments,
                                            lldb::SBError &error);
 
   /// Set given target object as a current target for lldb-vscode and start
   /// listeing for its breakpoint events.
   void SetTarget(const lldb::SBTarget target);
+
+  const std::map<std::string, RequestCallback> &GetRequestHandlers();
+
+  PacketStatus GetObject(llvm::json::Object &object);
+  bool HandleObject(const llvm::json::Object &object);
+  PacketStatus SendReverseRequest(llvm::json::Object &request,
+                                  llvm::json::Object &response);
+
+  void RegisterRequestCallback(std::string request, RequestCallback callback);
 };
 
 extern VSCode g_vsc;
 
 } // namespace lldb_vscode
 
 #endif

lldb/tools/lldb-vscode/VSCode.cpp

 //===-- VSCode.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include <stdarg.h>
 #include <fstream>
 #include <mutex>
+#include <stdarg.h>
 
 #include "LLDBUtils.h"
 #include "VSCode.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #if defined(_WIN32)
 #define NOMINMAX
-#include <windows.h>
 #include <fcntl.h>
 #include <io.h>
+#include <windows.h>
 #endif
 
 using namespace lldb_vscode;
 
 namespace lldb_vscode {
 
 VSCode g_vsc;
 
 VSCode::VSCode()
     : variables(), broadcaster("lldb-vscode"), num_regs(0), num_locals(0),
       num_globals(0), log(),
       exception_breakpoints(
           {{"cpp_catch", "C++ Catch", lldb::eLanguageTypeC_plus_plus},
            {"cpp_throw", "C++ Throw", lldb::eLanguageTypeC_plus_plus},
            {"objc_catch", "Objective C Catch", lldb::eLanguageTypeObjC},
            {"objc_throw", "Objective C Throw", lldb::eLanguageTypeObjC},
            {"swift_catch", "Swift Catch", lldb::eLanguageTypeSwift},
            {"swift_throw", "Swift Throw", lldb::eLanguageTypeSwift}}),
       focus_tid(LLDB_INVALID_THREAD_ID), sent_terminated_event(false),
       stop_at_entry(false), is_attach(false) {
   const char *log_file_path = getenv("LLDBVSCODE_LOG");
 #if defined(_WIN32)
   // Windows opens stdout and stdin in text mode which converts \n to 13,10
   // while the value is just 10 on Darwin/Linux. Setting the file mode to binary
   // fixes this.
   int result = _setmode(fileno(stdout), _O_BINARY);
   assert(result);
   result = _setmode(fileno(stdin), _O_BINARY);
   (void)result;
   assert(result);
 #endif
   if (log_file_path)
     log.reset(new std::ofstream(log_file_path));
 }
 
-VSCode::~VSCode() {
-}
+VSCode::~VSCode() {}
 
 int64_t VSCode::GetLineForPC(int64_t sourceReference, lldb::addr_t pc) const {
   auto pos = source_map.find(sourceReference);
   if (pos != source_map.end())
     return pos->second.GetLineForPC(pc);
   return 0;
 }
 

 
 void __attribute__((format(printf, 3, 4)))
 VSCode::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))));
+  SendOutput(
+      o, llvm::StringRef(buffer, std::min<int>(actual_length, sizeof(buffer))));
 }
 
 int64_t VSCode::GetNextSourceReference() {
   static int64_t ref = 0;
   return ++ref;
 }
 
 ExceptionBreakpoint *

 void VSCode::RunExitCommands() {
   RunLLDBCommands("Running exitCommands:", exit_commands);
 }
 
 void VSCode::RunTerminateCommands() {
   RunLLDBCommands("Running terminateCommands:", terminate_commands);
 }
 
-lldb::SBTarget VSCode::CreateTargetFromArguments(
-    const llvm::json::Object &arguments,
+lldb::SBTarget
+VSCode::CreateTargetFromArguments(const llvm::json::Object &arguments,
                                   lldb::SBError &error) {
   // Grab the name of the program we need to debug and create a target using
   // the given program as an argument. Executable file can be a source of target
   // architecture and platform, if they differ from the host. Setting exe path
   // in launch info is useless because Target.Launch() will not change
   // architecture and platform, therefore they should be known at the target
   // creation. We also use target triple and platform from the launch
   // configuration, if given, since in some cases ELF file doesn't contain
   // enough information to determine correct arch and platform (or ELF can be
   // omitted at all), so it is good to leave the user an apportunity to specify
   // those. Any of those three can be left empty.
   llvm::StringRef target_triple = GetString(arguments, "targetTriple");
   llvm::StringRef platform_name = GetString(arguments, "platformName");
   llvm::StringRef program = GetString(arguments, "program");
   auto target = this->debugger.CreateTarget(
-    program.data(),
-    target_triple.data(),
-    platform_name.data(),
+      program.data(), target_triple.data(), platform_name.data(),
       true, // Add dependent modules.
-    error
-  );
+      error);
 
   if (error.Fail()) {
     // Update message if there was an error.
     error.SetErrorStringWithFormat(
-        "Could not create a target for a program '%s': %s.",
-        program.data(), error.GetCString());
+        "Could not create a target for a program '%s': %s.", program.data(),
+        error.GetCString());
   }
 
   return target;
 }
 
 void VSCode::SetTarget(const lldb::SBTarget target) {
   this->target = target;
 
   if (target.IsValid()) {
     // Configure breakpoint event listeners for the target.
     lldb::SBListener listener = this->debugger.GetListener();
     listener.StartListeningForEvents(
         this->target.GetBroadcaster(),
         lldb::SBTarget::eBroadcastBitBreakpointChanged);
     listener.StartListeningForEvents(this->broadcaster,
                                      eBroadcastBitStopEventThread);
     listener.StartListeningForEvents(
         this->target.GetBroadcaster(),
         lldb::SBTarget::eBroadcastBitModulesLoaded |
             lldb::SBTarget::eBroadcastBitModulesUnloaded |
-          lldb::SBTarget::eBroadcastBitSymbolsLoaded);                                
+            lldb::SBTarget::eBroadcastBitSymbolsLoaded);
   }
 }
 
+VSCode::PacketStatus VSCode::GetObject(llvm::json::Object &object) {
+  std::string json = ReadJSON();
+  if (json.empty())
+    return PacketStatus::EndOfFile;
+
+  llvm::StringRef json_sref(json);
+  llvm::Expected<llvm::json::Value> json_value = llvm::json::parse(json_sref);
+  if (!json_value) {
+    auto error = json_value.takeError();
+    if (log) {
+      std::string error_str;
+      llvm::raw_string_ostream strm(error_str);
+      strm << error;
+      strm.flush();
+      *log << "error: failed to parse JSON: " << error_str << std::endl
+           << json << std::endl;
+    }
+    return PacketStatus::JSONMalformed;
+  }
+  object = *json_value->getAsObject();
+  if (!json_value->getAsObject()) {
+    if (log)
+      *log << "error: json packet isn't a object" << std::endl;
+    return PacketStatus::JSONNotObject;
+  }
+  return PacketStatus::Success;
+}
+
+bool VSCode::HandleObject(const llvm::json::Object &object) {
+  const auto packet_type = GetString(object, "type");
+  if (packet_type == "request") {
+    const auto command = GetString(object, "command");
+    auto handler_pos = m_request_handlers.find(std::string(command));
+    if (handler_pos != m_request_handlers.end()) {
+      handler_pos->second(object);
+      return true; // Success
+    } else {
+      if (log)
+        *log << "error: unhandled command \"" << command.data() << std::endl;
+      return false; // Fail
+    }
+  }
+  return false;
+}
+
+VSCode::PacketStatus VSCode::SendReverseRequest(llvm::json::Object &request,
+                                                llvm::json::Object &response) {
+  // Put the right "seq" into the packet here, so we don't have to do it from
+  // where we send the reverse request.
+  request.try_emplace("seq", ++reverse_request_seq);
+  SendJSON(llvm::json::Value(std::move(request)));
+  bool got_response = false;
+  while (!got_response) {
+    PacketStatus status = GetObject(response);
+    const auto packet_type = GetString(response, "type");
+    if (packet_type == "response") {
+      if (status == PacketStatus::Success) {
+        return status;
+        // Not our response, we got another packet
+        HandleObject(response);
+      } else {
+        return status;
+      }
+    }
+  }
+}
+
+void VSCode::RegisterRequestCallback(std::string request,
+                                     RequestCallback callback) {
+  m_request_handlers[request] = callback;
+}
+
 } // namespace lldb_vscode

lldb/tools/lldb-vscode/lldb-vscode.cpp

 }
 
 // Grab any STDOUT and STDERR from the process and send it up to VS Code
 // via an "output" event to the "stdout" and "stderr" categories.
 void SendStdOutStdErr(lldb::SBProcess &process) {
   char buffer[1024];
   size_t count;
   while ((count = process.GetSTDOUT(buffer, sizeof(buffer))) > 0)
     g_vsc.SendOutput(OutputType::Stdout, llvm::StringRef(buffer, count));
   while ((count = process.GetSTDERR(buffer, sizeof(buffer))) > 0)
     g_vsc.SendOutput(OutputType::Stderr, llvm::StringRef(buffer, count));
 }
 
 // All events from the debugger, target, process, thread and frames are
 // received in this function that runs in its own thread. We are using a
 // "FILE *" to output packets back to VS Code and they have mutexes in them
 // them prevent multiple threads from writing simultaneously so no locking
if (listener.WaitForEvent(1, event)) {
           for (int i = 0; i < num_modules; i++) {
             auto module = lldb::SBTarget::GetModuleAtIndexFromEvent(i, event);
             auto module_event = CreateEventObject("module");
             llvm::json::Value module_value = CreateModule(module);
             llvm::json::Object body;
             if (event_mask & lldb::SBTarget::eBroadcastBitModulesLoaded) {
               body.try_emplace("reason", "new");
             } else if (event_mask &
-                        lldb::SBTarget::eBroadcastBitModulesUnloaded) {
               body.try_emplace("reason", "removed");
             } else if (event_mask &
-                        lldb::SBTarget::eBroadcastBitSymbolsLoaded) {
               body.try_emplace("reason", "changed");
             }
             body.try_emplace("module", module_value);
             module_event.try_emplace("body", std::move(body));
             g_vsc.SendJSON(llvm::json::Value(std::move(module_event)));
           }
         }
       } else if (event.BroadcasterMatchesRef(g_vsc.broadcaster)) {
void request_exceptionInfo(const llvm::json::Object &request) {
   }
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
 // "CompletionsRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
-//     "description": "Returns a list of possible completions for a given caret position and text.\nThe CompletionsRequest may only be called if the 'supportsCompletionsRequest' capability exists and is true.",
+//     "description": "Returns a list of possible completions for a given caret
+//     position and text.\nThe CompletionsRequest may only be called if the
+//     'supportsCompletionsRequest' capability exists and is true.",
 //     "properties": {
 //       "command": {
 //         "type": "string",
 //         "enum": [ "completions" ]
 //       },
 //       "arguments": {
 //         "$ref": "#/definitions/CompletionsArguments"
 //       }
 //     },
 //     "required": [ "command", "arguments"  ]
 //   }]
 // },
 // "CompletionsArguments": {
 //   "type": "object",
 //   "description": "Arguments for 'completions' request.",
 //   "properties": {
 //     "frameId": {
 //       "type": "integer",
-//       "description": "Returns completions in the scope of this stack frame. If not specified, the completions are returned for the global scope."
+//       "description": "Returns completions in the scope of this stack frame.
+//       If not specified, the completions are returned for the global scope."
 //     },
 //     "text": {
 //       "type": "string",
-//       "description": "One or more source lines. Typically this is the text a user has typed into the debug console before he asked for completion."
+//       "description": "One or more source lines. Typically this is the text a
+//       user has typed into the debug console before he asked for completion."
 //     },
 //     "column": {
 //       "type": "integer",
-//       "description": "The character position for which to determine the completion proposals."
+//       "description": "The character position for which to determine the
+//       completion proposals."
 //     },
 //     "line": {
 //       "type": "integer",
-//       "description": "An optional line for which to determine the completion proposals. If missing the first line of the text is assumed."
+//       "description": "An optional line for which to determine the completion
+//       proposals. If missing the first line of the text is assumed."
 //     }
 //   },
 //   "required": [ "text", "column" ]
 // },
 // "CompletionsResponse": {
 //   "allOf": [ { "$ref": "#/definitions/Response" }, {
 //     "type": "object",
 //     "description": "Response to 'completions' request.",

 //         "required": [ "targets" ]
 //       }
 //     },
 //     "required": [ "body" ]
 //   }]
 // },
 // "CompletionItem": {
 //   "type": "object",
-//   "description": "CompletionItems are the suggestions returned from the CompletionsRequest.",
-//   "properties": {
+//   "description": "CompletionItems are the suggestions returned from the
+//   CompletionsRequest.", "properties": {
 //     "label": {
 //       "type": "string",
-//       "description": "The label of this completion item. By default this is also the text that is inserted when selecting this completion."
+//       "description": "The label of this completion item. By default this is
+//       also the text that is inserted when selecting this completion."
 //     },
 //     "text": {
 //       "type": "string",
-//       "description": "If text is not falsy then it is inserted instead of the label."
+//       "description": "If text is not falsy then it is inserted instead of the
+//       label."
 //     },
 //     "sortText": {
 //       "type": "string",
-//       "description": "A string that should be used when comparing this item with other items. When `falsy` the label is used."
+//       "description": "A string that should be used when comparing this item
+//       with other items. When `falsy` the label is used."
 //     },
 //     "type": {
 //       "$ref": "#/definitions/CompletionItemType",
-//       "description": "The item's type. Typically the client uses this information to render the item in the UI with an icon."
+//       "description": "The item's type. Typically the client uses this
+//       information to render the item in the UI with an icon."
 //     },
 //     "start": {
 //       "type": "integer",
-//       "description": "This value determines the location (in the CompletionsRequest's 'text' attribute) where the completion text is added.\nIf missing the text is added at the location specified by the CompletionsRequest's 'column' attribute."
+//       "description": "This value determines the location (in the
+//       CompletionsRequest's 'text' attribute) where the completion text is
+//       added.\nIf missing the text is added at the location specified by the
+//       CompletionsRequest's 'column' attribute."
 //     },
 //     "length": {
 //       "type": "integer",
-//       "description": "This value determines how many characters are overwritten by the completion text.\nIf missing the value 0 is assumed which results in the completion text being inserted."
+//       "description": "This value determines how many characters are
+//       overwritten by the completion text.\nIf missing the value 0 is assumed
+//       which results in the completion text being inserted."
 //     }
 //   },
 //   "required": [ "label" ]
 // },
 // "CompletionItemType": {
 //   "type": "string",
-//   "description": "Some predefined types for the CompletionItem. Please note that not all clients have specific icons for all of them.",
-//   "enum": [ "method", "function", "constructor", "field", "variable", "class", "interface", "module", "property", "unit", "value", "enum", "keyword", "snippet", "text", "color", "file", "reference", "customcolor" ]
+//   "description": "Some predefined types for the CompletionItem. Please note
+//   that not all clients have specific icons for all of them.", "enum": [
+//   "method", "function", "constructor", "field", "variable", "class",
+//   "interface", "module", "property", "unit", "value", "enum", "keyword",
+//   "snippet", "text", "color", "file", "reference", "customcolor" ]
 // }
 void request_completions(const llvm::json::Object &request) {
   llvm::json::Object response;
   FillResponse(request, response);
   llvm::json::Object body;
   auto arguments = request.getObject("arguments");
   std::string text = std::string(GetString(arguments, "text"));
   auto original_column = GetSigned(arguments, "column", text.size());
if (!text.empty() && text[0] == '`') {
     actual_column--;
   } else {
     text = "p " + text;
     actual_column += 2;
   }
   lldb::SBStringList matches;
   lldb::SBStringList descriptions;
   g_vsc.debugger.GetCommandInterpreter().HandleCompletionWithDescriptions(
-    text.c_str(),
-    actual_column,
-    0, -1, matches, descriptions);
+      text.c_str(), actual_column, 0, -1, matches, descriptions);
   size_t count = std::min((uint32_t)100, matches.GetSize());
   targets.reserve(count);
   for (size_t i = 0; i < count; i++) {
     std::string match = matches.GetStringAtIndex(i);
     std::string description = descriptions.GetStringAtIndex(i);
 
     llvm::json::Object item;
 
     llvm::StringRef match_ref = match;
-    for(llvm::StringRef commit_point: {".", "->"}) {
-      if (match_ref.contains(commit_point)){
+    for (llvm::StringRef commit_point : {".", "->"}) {
+      if (match_ref.contains(commit_point)) {
         match_ref = match_ref.rsplit(commit_point).second;
       }
     }
     EmplaceSafeString(item, "text", match_ref);
 
     if (description.empty())
       EmplaceSafeString(item, "label", match);
     else
if (value.GetError().Fail()) {
       const char *error_cstr = error.GetCString();
       if (error_cstr && error_cstr[0])
         EmplaceSafeString(response, "message", std::string(error_cstr));
       else
         EmplaceSafeString(response, "message", "evaluate failed");
     } else {
       SetValueForKey(value, body, "result");
       auto value_typename = value.GetType().GetDisplayTypeName();
-      EmplaceSafeString(body, "type", value_typename ? value_typename : NO_TYPENAME);
+      EmplaceSafeString(body, "type",
+                        value_typename ? value_typename : NO_TYPENAME);
       if (value.MightHaveChildren()) {
         auto variablesReference = VARIDX_TO_VARREF(g_vsc.variables.GetSize());
         g_vsc.variables.Append(value);
         body.try_emplace("variablesReference", variablesReference);
       } else {
         body.try_emplace("variablesReference", (int64_t)0);
       }
     }
void request_getCompileUnits(const llvm::json::Object &request) {
   auto arguments = request.getObject("arguments");
   std::string module_id = std::string(GetString(arguments, "moduleId"));
   int num_modules = g_vsc.target.GetNumModules();
   for (int i = 0; i < num_modules; i++) {
     auto curr_module = g_vsc.target.GetModuleAtIndex(i);
     if (module_id == curr_module.GetUUIDString()) {
       int num_units = curr_module.GetNumCompileUnits();
       for (int j = 0; j < num_units; j++) {
-        auto curr_unit = curr_module.GetCompileUnitAtIndex(j);\
-        units.emplace_back(CreateCompileUnit(curr_unit));\
+        auto curr_unit = curr_module.GetCompileUnitAtIndex(j);
+        units.emplace_back(CreateCompileUnit(curr_unit));
       }
       body.try_emplace("compileUnits", std::move(units));
       break;
     }
   }
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
void request_initialize(const llvm::json::Object &request) {
   // data hovers.
   body.try_emplace("supportsEvaluateForHovers", true);
   // Available filters or options for the setExceptionBreakpoints request.
   llvm::json::Array filters;
   for (const auto &exc_bp : g_vsc.exception_breakpoints) {
     filters.emplace_back(CreateExceptionBreakpointFilter(exc_bp));
   }
   body.try_emplace("exceptionBreakpointFilters", std::move(filters));
+  // The debug adapter supports launching a debugee in intergrated VSCode
+  // terminal.
+  body.try_emplace("supportsRunInTerminalRequest", true);
   // The debug adapter supports stepping back via the stepBack and
   // reverseContinue requests.
   body.try_emplace("supportsStepBack", false);
   // The debug adapter supports setting a variable to a value.
   body.try_emplace("supportsSetVariable", true);
   // The debug adapter supports restarting a frame.
   body.try_emplace("supportsRestartFrame", false);
   // The debug adapter supports the gotoTargetsRequest.
void request_initialize(const llvm::json::Object &request) {
   body.try_emplace("supportsDelayedStackTraceLoading", true);
   // The debug adapter supports the 'loadedSources' request.
   body.try_emplace("supportsLoadedSourcesRequest", false);
 
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
+void request_runInTerminal(const llvm::json::Object &request,
+                           llvm::json::Object &launch_response) {
+  // Fill out attach info
+  g_vsc.is_attach = true;
+  lldb::SBError error;
+  lldb::SBAttachInfo attach_info;
+  attach_info.SetWaitForLaunch(true, false);
+  // Manually set stopOnEntry as lldb cannot gather this info from the request
+  g_vsc.stop_at_entry = true;
+  auto attach_func = [&]() { g_vsc.target.Attach(attach_info, error); };
+  std::thread attacher(attach_func);
+
+  // Send reverse request for run in terminal
+  auto arguments = request.getObject("arguments");
+  llvm::json::Object reverseRequest;
+  reverseRequest.try_emplace("type", "request");
+  reverseRequest.try_emplace("command", "runInTerminal");
+  llvm::json::Object runInTerminalArgs;
+  runInTerminalArgs.try_emplace("kind", "integrated");
+  const auto cwd = GetString(arguments, "cwd");
+  if (!cwd.empty())
+    runInTerminalArgs.try_emplace("cwd", cwd);
+
+  std::vector<std::string> commands = GetStrings(arguments, "args");
+  commands.insert(commands.begin(),
+                  std::string(GetString(arguments, "program").data()));
+  runInTerminalArgs.try_emplace("args", commands);
+  std::vector<std::string> envVars = GetStrings(arguments, "env");
+  llvm::json::Object environment;
+  for (std::string envVar : envVars) {
+    size_t ind = envVar.find("=");
+    environment.try_emplace(envVar.substr(0, ind), envVar.substr(ind + 1));
+  }
+  runInTerminalArgs.try_emplace("env",
+                                llvm::json::Value(std::move(environment)));
+  reverseRequest.try_emplace("arguments",
+                             llvm::json::Value(std::move(runInTerminalArgs)));
+  llvm::json::Object reverseResponse;
+  lldb_vscode::VSCode::PacketStatus status =
+      g_vsc.SendReverseRequest(reverseRequest, reverseResponse);
+  if (status == lldb_vscode::VSCode::PacketStatus::Success) {
+    attacher.join();
+  } else {
+    // Reverse Request handshake fails
+    error.SetErrorString("Process cannot be launched by IDE.");
+  }
+
+  if (error.Success()) {
+    // IDE doesn't respond back the pid of the target, so lldb can only attach
+    // by process name, which is already set up in request_launch().
+    auto attached_pid = g_vsc.target.GetProcess().GetProcessID();
+    if (attached_pid == LLDB_INVALID_PROCESS_ID) {
+      error.SetErrorString("Failed to attach to a process");
+    }
+  }
+  if (error.Fail()) {
+    launch_response["success"] = llvm::json::Value(false);
+    EmplaceSafeString(launch_response, "message",
+                      std::string(error.GetCString()));
+    return;
+  }
+  if (error.Success()) {
+    SendProcessEvent(Attach);
+    launch_response["success"] = llvm::json::Value(true);
+  } else {
+    // Attach fails
+    launch_response["success"] = llvm::json::Value(false);
+  }
+  g_vsc.SendJSON(CreateEventObject("initialized"));
+}
+
 // "LaunchRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "Launch request; value of command field is 'launch'.",
 //     "properties": {
 //       "command": {
 //         "type": "string",
 //         "enum": [ "launch" ]
void request_launch(const llvm::json::Object &request) {
   g_vsc.SetTarget(g_vsc.CreateTargetFromArguments(*arguments, status));
   if (status.Fail()) {
     response["success"] = llvm::json::Value(false);
     EmplaceSafeString(response, "message", status.GetCString());
     g_vsc.SendJSON(llvm::json::Value(std::move(response)));
     return;
   }
 
+  if (GetBoolean(arguments, "launchInTerminal", false)) {
+    request_runInTerminal(request, response);
+    g_vsc.SendJSON(llvm::json::Value(std::move(response)));
+  } else {
     // Instantiate a launch info instance for the target.
     auto launch_info = g_vsc.target.GetLaunchInfo();
 
     // Grab the current working directory if there is one and set it in the
     // launch info.
     const auto cwd = GetString(arguments, "cwd");
     if (!cwd.empty())
       launch_info.SetWorkingDirectory(cwd.data());
 
     // Extract any extra arguments and append them to our program arguments for
     // when we launch
     auto args = GetStrings(arguments, "args");
     if (!args.empty())
       launch_info.SetArguments(MakeArgv(args).data(), true);
 
     // Pass any environment variables along that the user specified.
     auto envs = GetStrings(arguments, "env");
     if (!envs.empty())
       launch_info.SetEnvironmentEntries(MakeArgv(envs).data(), true);
 
     auto flags = launch_info.GetLaunchFlags();
 
     if (GetBoolean(arguments, "disableASLR", true))
       flags |= lldb::eLaunchFlagDisableASLR;
     if (GetBoolean(arguments, "disableSTDIO", false))
       flags |= lldb::eLaunchFlagDisableSTDIO;
     if (GetBoolean(arguments, "shellExpandArguments", false))
       flags |= lldb::eLaunchFlagShellExpandArguments;
     const bool detatchOnError = GetBoolean(arguments, "detachOnError", false);
     launch_info.SetDetachOnError(detatchOnError);
     launch_info.SetLaunchFlags(flags | lldb::eLaunchFlagDebug |
                                lldb::eLaunchFlagStopAtEntry);
 
     // Run any pre run LLDB commands the user specified in the launch.json
     g_vsc.RunPreRunCommands();
     if (launchCommands.empty()) {
-    // Disable async events so the launch will be successful when we return from
-    // the launch call and the launch will happen synchronously
+      // Disable async events so the launch will be successful when we return
+      // from the launch call and the launch will happen synchronously
       g_vsc.debugger.SetAsync(false);
       g_vsc.target.Launch(launch_info, error);
       g_vsc.debugger.SetAsync(true);
     } else {
       g_vsc.RunLLDBCommands("Running launchCommands:", launchCommands);
-    // The custom commands might have created a new target so we should use the
-    // selected target after these commands are run.
+      // The custom commands might have created a new target so we should use
+      // the selected target after these commands are run.
       g_vsc.target = g_vsc.debugger.GetSelectedTarget();
     }
 
     if (error.Fail()) {
       response["success"] = llvm::json::Value(false);
       EmplaceSafeString(response, "message", std::string(error.GetCString()));
     }
-  g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 
+    g_vsc.SendJSON(llvm::json::Value(std::move(response)));
     SendProcessEvent(Launch);
     g_vsc.SendJSON(llvm::json::Value(CreateEventObject("initialized")));
     // Reenable async events and start the event thread to catch async events.
     // g_vsc.debugger.SetAsync(true);
   }
+}
 
 // "NextRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "Next request; value of command field is 'next'. The
 //                     request starts the debuggee to run again for one step.
 //                     The debug adapter first sends the NextResponse and then
 //                     a StoppedEvent (event type 'step') after the step has
for (const auto &value : *breakpoints) {
     FunctionBreakpoint func_bp(*bp_obj);
     request_bps[func_bp.functionName] = std::move(func_bp);
   }
 
   std::vector<llvm::StringRef> remove_names;
   // Disable any function breakpoints that aren't in the request_bps.
   // There is no call to remove function breakpoints other than calling this
   // function with a smaller or empty "breakpoints" list.
-  for (auto &pair: g_vsc.function_breakpoints) {
+  for (auto &pair : g_vsc.function_breakpoints) {
     auto request_pos = request_bps.find(pair.first());
     if (request_pos == request_bps.end()) {
       // This function breakpoint no longer exists delete it from LLDB
       g_vsc.target.BreakpointDelete(pair.second.bp.GetID());
       remove_names.push_back(pair.first());
     } else {
       // Update the existing breakpoint as any setting withing the function
       // breakpoint might have changed.
       pair.second.UpdateBreakpoint(request_pos->second);
       // Remove this breakpoint from the request breakpoints since we have
       // handled it here and we don't need to set a new breakpoint below.
       request_bps.erase(request_pos);
       // Add this breakpoint info to the response
       AppendBreakpoint(pair.second.bp, response_breakpoints);
     }
   }
   // Remove any breakpoints that are no longer in our list
-  for (const auto &name: remove_names)
+  for (const auto &name : remove_names)
     g_vsc.function_breakpoints.erase(name);
 
   // Any breakpoints that are left in "request_bps" are breakpoints that
   // need to be set.
   for (auto &pair : request_bps) {
     pair.second.SetBreakpoint();
     // Add this breakpoint info to the response
     AppendBreakpoint(pair.second.bp, response_breakpoints);
for (uint32_t i = 0; g_vsc.target.GetBreakpointAtIndex(i).IsValid(); ++i) {
     AppendBreakpoint(bp, response_breakpoints);
   }
   llvm::json::Object body;
   body.try_emplace("breakpoints", std::move(response_breakpoints));
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
-const std::map<std::string, RequestCallback> &GetRequestHandlers() {
-#define REQUEST_CALLBACK(name)                                                 \
-  { #name, request_##name }
-  static std::map<std::string, RequestCallback> g_request_handlers = {
-      // VSCode Debug Adaptor requests
-      REQUEST_CALLBACK(attach),
-      REQUEST_CALLBACK(completions),
-      REQUEST_CALLBACK(continue),
-      REQUEST_CALLBACK(configurationDone),
-      REQUEST_CALLBACK(disconnect),
-      REQUEST_CALLBACK(evaluate),
-      REQUEST_CALLBACK(exceptionInfo),
-      REQUEST_CALLBACK(getCompileUnits),
-      REQUEST_CALLBACK(initialize),
-      REQUEST_CALLBACK(launch),
-      REQUEST_CALLBACK(next),
-      REQUEST_CALLBACK(pause),
-      REQUEST_CALLBACK(scopes),
-      REQUEST_CALLBACK(setBreakpoints),
-      REQUEST_CALLBACK(setExceptionBreakpoints),
-      REQUEST_CALLBACK(setFunctionBreakpoints),
-      REQUEST_CALLBACK(setVariable),
-      REQUEST_CALLBACK(source),
-      REQUEST_CALLBACK(stackTrace),
-      REQUEST_CALLBACK(stepIn),
-      REQUEST_CALLBACK(stepOut),
-      REQUEST_CALLBACK(threads),
-      REQUEST_CALLBACK(variables),
-      // Testing requests
-      REQUEST_CALLBACK(_testGetTargetBreakpoints),
-  };
-#undef REQUEST_CALLBACK
-  return g_request_handlers;
+const void RegisterRequestCallbacks() {
+  g_vsc.RegisterRequestCallback("attach", request_attach);
+  g_vsc.RegisterRequestCallback("completions", request_completions);
+  g_vsc.RegisterRequestCallback("continue", request_continue);
+  g_vsc.RegisterRequestCallback("configurationDone", request_configurationDone);
+  g_vsc.RegisterRequestCallback("disconnect", request_disconnect);
+  g_vsc.RegisterRequestCallback("evaluate", request_evaluate);
+  g_vsc.RegisterRequestCallback("exceptionInfo", request_exceptionInfo);
+  g_vsc.RegisterRequestCallback("getCompileUnits", request_getCompileUnits);
+  g_vsc.RegisterRequestCallback("initialize", request_initialize);
+  g_vsc.RegisterRequestCallback("launch", request_launch);
+  g_vsc.RegisterRequestCallback("next", request_next);
+  g_vsc.RegisterRequestCallback("pause", request_pause);
+  g_vsc.RegisterRequestCallback("scopes", request_scopes);
+  g_vsc.RegisterRequestCallback("setBreakpoints", request_setBreakpoints);
+  g_vsc.RegisterRequestCallback("setExceptionBreakpoints",
+                                request_setExceptionBreakpoints);
+  g_vsc.RegisterRequestCallback("setFunctionBreakpoints",
+                                request_setFunctionBreakpoints);
+  g_vsc.RegisterRequestCallback("setVariable", request_setVariable);
+  g_vsc.RegisterRequestCallback("source", request_source);
+  g_vsc.RegisterRequestCallback("stackTrace", request_stackTrace);
+  g_vsc.RegisterRequestCallback("stepIn", request_stepIn);
+  g_vsc.RegisterRequestCallback("stepOut", request_stepOut);
+  g_vsc.RegisterRequestCallback("threads", request_threads);
+  g_vsc.RegisterRequestCallback("variables", request_variables);
+  g_vsc.RegisterRequestCallback("_testGetTargetBreakpoints",
+                                request__testGetTargetBreakpoints);
 }
 
 } // anonymous namespace
 
 static void printHelp(LLDBVSCodeOptTable &table, llvm::StringRef tool_name) {
   std::string usage_str = tool_name.str() + "options";
   table.PrintHelp(llvm::outs(), usage_str.c_str(), "LLDB VSCode", false);
 
EXAMPLES:
   debugger to attach to the process.
 
     lldb-vscode -g
   )___";
   llvm::outs() << examples;
 }
 
 int main(int argc, char *argv[]) {
-
+  RegisterRequestCallbacks();
   // Initialize LLDB first before we do anything.
   lldb::SBDebugger::Initialize();
 
   int portno = -1;
 
   LLDBVSCodeOptTable T;
   unsigned MAI, MAC;
   llvm::ArrayRef<const char *> ArgsArr = llvm::makeArrayRef(argv + 1, argc);
if (portno != -1) {
     } else {
       exit(1);
     }
   } else {
     g_vsc.input.descriptor = StreamDescriptor::from_file(fileno(stdin), false);
     g_vsc.output.descriptor =
         StreamDescriptor::from_file(fileno(stdout), false);
   }
-  auto request_handlers = GetRequestHandlers();
   uint32_t packet_idx = 0;
   while (!g_vsc.sent_terminated_event) {
-    std::string json = g_vsc.ReadJSON();
-    if (json.empty())
+    llvm::json::Object object;
+    lldb_vscode::VSCode::PacketStatus status = g_vsc.GetObject(object);
+    if (status == lldb_vscode::VSCode::PacketStatus::EndOfFile)
       break;
+    if (status != lldb_vscode::VSCode::PacketStatus::Success)
+      return 1; // Fatal error
 
-    llvm::StringRef json_sref(json);
-    llvm::Expected<llvm::json::Value> json_value = llvm::json::parse(json_sref);
-    if (!json_value) {
-      auto error = json_value.takeError();
-      if (g_vsc.log) {
-        std::string error_str;
-        llvm::raw_string_ostream strm(error_str);
-        strm << error;
-        strm.flush();
-
-        *g_vsc.log << "error: failed to parse JSON: " << error_str << std::endl
-                   << json << std::endl;
-      }
-      return 1;
-    }
-
-    auto object = json_value->getAsObject();
-    if (!object) {
-      if (g_vsc.log)
-        *g_vsc.log << "error: json packet isn't a object" << std::endl;
-      return 1;
-    }
-
-    const auto packet_type = GetString(object, "type");
-    if (packet_type == "request") {
-      const auto command = GetString(object, "command");
-      auto handler_pos = request_handlers.find(std::string(command));
-      if (handler_pos != request_handlers.end()) {
-        handler_pos->second(*object);
-      } else {
-        if (g_vsc.log)
-          *g_vsc.log << "error: unhandled command \"" << command.data() << std::endl;
-        return 1;
-      }
-    }
+    if (!g_vsc.HandleObject(object))
     ++packet_idx;
   }
 
   // We must terminate the debugger in a thread before the C++ destructor
   // chain messes everything up.
   lldb::SBDebugger::Terminate();
   return 0;
 }