//===-- lldb-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 "VSCode.h"

#include <cassert>

#include <climits>

#include <cstdarg>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <sys/stat.h>

#include <sys/types.h>

#if defined(_WIN32)

// We need to #define NOMINMAX in order to skip `min()` and `max()` macro

// definitions that conflict with other system headers.

// We also need to #undef GetObject (which is defined to GetObjectW) because

// the JSON code we use also has methods named `GetObject()` and we conflict

// against these.

#define NOMINMAX

#include <windows.h>

#undef GetObject

#include <io.h>

#else

#include <netinet/in.h>

#include <sys/socket.h>

#include <unistd.h>

#endif

#if defined(__linux__)

#include <sys/prctl.h>

#endif

#include <algorithm>

#include <chrono>

#include <fstream>

#include <map>

#include <memory>

#include <mutex>

#include <set>

#include <sstream>

#include <thread>

#include <vector>

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/ScopeExit.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/Option/Arg.h"

#include "llvm/Option/ArgList.h"

#include "llvm/Option/OptTable.h"

#include "llvm/Option/Option.h"

#include "llvm/Support/Errno.h"

#include "llvm/Support/FileSystem.h"

#include "llvm/Support/InitLLVM.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/PrettyStackTrace.h"

#include "llvm/Support/raw_ostream.h"

#include "JSONUtils.h"

#include "LLDBUtils.h"

#include "OutputRedirector.h"

#if defined(_WIN32)

#ifndef PATH_MAX

#define PATH_MAX MAX_PATH

#endif

typedef int socklen_t;

#endif

using namespace lldb_vscode;

namespace {

using namespace llvm::opt;

enum ID {

  OPT_INVALID = 0, // This is not an option ID.

#define OPTION(...) LLVM_MAKE_OPT_ID(__VA_ARGS__),

#include "Options.inc"

#undef OPTION

};

#define PREFIX(NAME, VALUE)                                                    \

  static constexpr llvm::StringLiteral NAME##_init[] = VALUE;                  \

  static constexpr llvm::ArrayRef<llvm::StringLiteral> NAME(                   \

      NAME##_init, std::size(NAME##_init) - 1);

#include "Options.inc"

#undef PREFIX

static constexpr llvm::opt::OptTable::Info InfoTable[] = {

#define OPTION(...) LLVM_CONSTRUCT_OPT_INFO(__VA_ARGS__),

#include "Options.inc"

#undef OPTION

};

class LLDBVSCodeOptTable : public llvm::opt::GenericOptTable {

public:

  LLDBVSCodeOptTable() : llvm::opt::GenericOptTable(InfoTable, true) {}

};

typedef void (*RequestCallback)(const llvm::json::Object &command);

enum LaunchMethod { Launch, Attach, AttachForSuspendedLaunch };

lldb::SBValueList *GetTopLevelScope(int64_t variablesReference) {

  switch (variablesReference) {

  case VARREF_LOCALS:

    return &g_vsc.variables.locals;

  case VARREF_GLOBALS:

    return &g_vsc.variables.globals;

  case VARREF_REGS:

    return &g_vsc.variables.registers;

  default:

    return nullptr;

  }

}

SOCKET AcceptConnection(int portno) {

  // Accept a socket connection from any host on "portno".

  SOCKET newsockfd = -1;

  struct sockaddr_in serv_addr, cli_addr;

  SOCKET sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if (sockfd < 0) {

    if (g_vsc.log)

      *g_vsc.log << "error: opening socket (" << strerror(errno) << ")"

                 << std::endl;

  } else {

    memset((char *)&serv_addr, 0, sizeof(serv_addr));

    serv_addr.sin_family = AF_INET;

    // serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

    serv_addr.sin_port = htons(portno);

    if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {

      if (g_vsc.log)

        *g_vsc.log << "error: binding socket (" << strerror(errno) << ")"

                   << std::endl;

    } else {

      listen(sockfd, 5);

      socklen_t clilen = sizeof(cli_addr);

      newsockfd =

          llvm::sys::RetryAfterSignal(static_cast<SOCKET>(-1), accept, sockfd,

                                      (struct sockaddr *)&cli_addr, &clilen);

      if (newsockfd < 0)

        if (g_vsc.log)

          *g_vsc.log << "error: accept (" << strerror(errno) << ")"

                     << std::endl;

    }

#if defined(_WIN32)

    closesocket(sockfd);

#else

    close(sockfd);

#endif

  }

  return newsockfd;

}

std::vector<const char *> MakeArgv(const llvm::ArrayRef<std::string> &strs) {

  // Create and return an array of "const char *", one for each C string in

  // "strs" and terminate the list with a NULL. This can be used for argument

  // vectors (argv) or environment vectors (envp) like those passed to the

  // "main" function in C programs.

  std::vector<const char *> argv;

  for (const auto &s : strs)

    argv.push_back(s.c_str());

  argv.push_back(nullptr);

  return argv;

}

// Send a "exited" event to indicate the process has exited.

void SendProcessExitedEvent(lldb::SBProcess &process) {

  llvm::json::Object event(CreateEventObject("exited"));

  llvm::json::Object body;

  body.try_emplace("exitCode", (int64_t)process.GetExitStatus());

  event.try_emplace("body", std::move(body));

  g_vsc.SendJSON(llvm::json::Value(std::move(event)));

}

void SendThreadExitedEvent(lldb::tid_t tid) {

  llvm::json::Object event(CreateEventObject("thread"));

  llvm::json::Object body;

  body.try_emplace("reason", "exited");

  body.try_emplace("threadId", (int64_t)tid);

  event.try_emplace("body", std::move(body));

  g_vsc.SendJSON(llvm::json::Value(std::move(event)));

}

// Send a "continued" event to indicate the process is in the running state.

void SendContinuedEvent() {

  lldb::SBProcess process = g_vsc.target.GetProcess();

  if (!process.IsValid()) {

    return;

  }

  // If the focus thread is not set then we haven't reported any thread status

  // to the client, so nothing to report.

  if (!g_vsc.configuration_done_sent ||

      g_vsc.focus_tid == LLDB_INVALID_THREAD_ID) {

    return;

  }

  llvm::json::Object event(CreateEventObject("continued"));

  llvm::json::Object body;

  body.try_emplace("threadId", (int64_t)g_vsc.focus_tid);

  body.try_emplace("allThreadsContinued", true);

  event.try_emplace("body", std::move(body));

  g_vsc.SendJSON(llvm::json::Value(std::move(event)));

}

// Send a "terminated" event to indicate the process is done being

// debugged.

void SendTerminatedEvent() {

  // If an inferior exits prior to the processing of a disconnect request, then

  // the threads executing EventThreadFunction and request_discontinue

  // respectively may call SendTerminatedEvent simultaneously. Without any

  // synchronization, the thread executing EventThreadFunction may set

  // g_vsc.sent_terminated_event before the thread executing

  // request_discontinue has had a chance to test it, in which case the latter

  // would move ahead to issue a response to the disconnect request. Said

  // response may get dispatched ahead of the terminated event compelling the

  // client to terminate the debug session without consuming any console output

  // that might've been generated by the execution of terminateCommands. So,

  // synchronize simultaneous calls to SendTerminatedEvent.

  static std::mutex mutex;

  std::lock_guard<std::mutex> locker(mutex);

  if (!g_vsc.sent_terminated_event) {

    g_vsc.sent_terminated_event = true;

    g_vsc.RunTerminateCommands();

    // Send a "terminated" event

    llvm::json::Object event(CreateTerminatedEventObject());

    g_vsc.SendJSON(llvm::json::Value(std::move(event)));

  }

}

// Send a thread stopped event for all threads as long as the process

// is stopped.

void SendThreadStoppedEvent() {

  lldb::SBProcess process = g_vsc.target.GetProcess();

  if (process.IsValid()) {

    auto state = process.GetState();

    if (state == lldb::eStateStopped) {

      llvm::DenseSet<lldb::tid_t> old_thread_ids;

      old_thread_ids.swap(g_vsc.thread_ids);

      uint32_t stop_id = process.GetStopID();

      const uint32_t num_threads = process.GetNumThreads();

      // First make a pass through the threads to see if the focused thread

      // has a stop reason. In case the focus thread doesn't have a stop

      // reason, remember the first thread that has a stop reason so we can

      // set it as the focus thread if below if needed.

      lldb::tid_t first_tid_with_reason = LLDB_INVALID_THREAD_ID;

      uint32_t num_threads_with_reason = 0;

      bool focus_thread_exists = false;

      for (uint32_t thread_idx = 0; thread_idx < num_threads; 
++thread_idx1
) {

        lldb::SBThread thread = process.GetThreadAtIndex(thread_idx);

        const lldb::tid_t tid = thread.GetThreadID();

        const bool has_reason = ThreadHasStopReason(thread);

        // If the focus thread doesn't have a stop reason, clear the thread ID

        if (tid == g_vsc.focus_tid) {

          focus_thread_exists = true;

          if (!has_reason)

            g_vsc.focus_tid = LLDB_INVALID_THREAD_ID;

        }

        if (has_reason) {

          ++num_threads_with_reason;

          if (first_tid_with_reason == LLDB_INVALID_THREAD_ID)

            first_tid_with_reason = tid;

        }

      }

      // We will have cleared g_vsc.focus_tid if the focus thread doesn't have

      // a stop reason, so if it was cleared, or wasn't set, or doesn't exist,

      // then set the focus thread to the first thread with a stop reason.

      if (!focus_thread_exists || 
g_vsc.focus_tid == 0
LLDB_INVALID_THREAD_ID0
)

        g_vsc.focus_tid = first_tid_with_reason;

      // If no threads stopped with a reason, then report the first one so

      // we at least let the UI know we stopped.

      if (num_threads_with_reason == 0) {

        lldb::SBThread thread = process.GetThreadAtIndex(0);

        g_vsc.focus_tid = thread.GetThreadID();

        g_vsc.SendJSON(CreateThreadStopped(thread, stop_id));

      } else {

        for (uint32_t thread_idx = 0; thread_idx < num_threads; 
++thread_idx1
) {

          lldb::SBThread thread = process.GetThreadAtIndex(thread_idx);

          g_vsc.thread_ids.insert(thread.GetThreadID());

          if (ThreadHasStopReason(thread)) {

            g_vsc.SendJSON(CreateThreadStopped(thread, stop_id));

          }

        }

      }

      for (auto tid : old_thread_ids) {

        auto end = g_vsc.thread_ids.end();

        auto pos = g_vsc.thread_ids.find(tid);

        if (pos == end)

          SendThreadExitedEvent(tid);

      }

    } else {

      if (g_vsc.log)

        *g_vsc.log << "error: SendThreadStoppedEvent() when process"

                      " isn't stopped ("

                   << lldb::SBDebugger::StateAsCString(state) << ')'

                   << std::endl;

    }

  } else {

    if (g_vsc.log)

      *g_vsc.log << "error: SendThreadStoppedEvent() invalid process"

                 << std::endl;

  }

  g_vsc.RunStopCommands();

}

// "ProcessEvent": {

//   "allOf": [

//     { "$ref": "#/definitions/Event" },

//     {

//       "type": "object",

//       "description": "Event message for 'process' event type. 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.",

//       "properties": {

//         "event": {

//           "type": "string",

//           "enum": [ "process" ]

//         },

//         "body": {

//           "type": "object",

//           "properties": {

//             "name": {

//               "type": "string",

//               "description": "The logical name of the process. This is

//                               usually the full path to process's executable

//                               file. Example: /home/myproj/program.js."

//             },

//             "systemProcessId": {

//               "type": "integer",

//               "description": "The system process id of the debugged process.

//                               This property will be missing for non-system

//                               processes."

//             },

//             "isLocalProcess": {

//               "type": "boolean",

//               "description": "If true, the process is running on the same

//                               computer as the debug adapter."

//             },

//             "startMethod": {

//               "type": "string",

//               "enum": [ "launch", "attach", "attachForSuspendedLaunch" ],

//               "description": "Describes how the debug engine started

//                               debugging this process.",

//               "enumDescriptions": [

//                 "Process was launched under the debugger.",

//                 "Debugger attached to an existing process.",

//                 "A project launcher component has launched a new process in

//                  a suspended state and then asked the debugger to attach."

//               ]

//             }

//           },

//           "required": [ "name" ]

//         }

//       },

//       "required": [ "event", "body" ]

//     }

//   ]

// }

void SendProcessEvent(LaunchMethod launch_method) {

  lldb::SBFileSpec exe_fspec = g_vsc.target.GetExecutable();

  char exe_path[PATH_MAX];

  exe_fspec.GetPath(exe_path, sizeof(exe_path));

  llvm::json::Object event(CreateEventObject("process"));

  llvm::json::Object body;

  EmplaceSafeString(body, "name", std::string(exe_path));

  const auto pid = g_vsc.target.GetProcess().GetProcessID();

  body.try_emplace("systemProcessId", (int64_t)pid);

  body.try_emplace("isLocalProcess", true);

  const char *startMethod = nullptr;

  switch (launch_method) {

  case Launch:

    startMethod = "launch";

    break;

  case Attach:

    startMethod = "attach";

    break;

  case AttachForSuspendedLaunch:

    startMethod = "attachForSuspendedLaunch";

    break;

  }

  body.try_emplace("startMethod", startMethod);

  event.try_emplace("body", std::move(body));

  g_vsc.SendJSON(llvm::json::Value(std::move(event)));

}

// 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));

}

void ProgressEventThreadFunction() {

  lldb::SBListener listener("lldb-vscode.progress.listener");

  g_vsc.debugger.GetBroadcaster().AddListener(

      listener, lldb::SBDebugger::eBroadcastBitProgress);

  g_vsc.broadcaster.AddListener(listener, eBroadcastBitStopProgressThread);

  lldb::SBEvent event;

  bool done = false;

  while (!done) {

    if (listener.WaitForEvent(1, event)) {

      const auto event_mask = event.GetType();

      if (event.BroadcasterMatchesRef(g_vsc.broadcaster)) {

        if (event_mask & eBroadcastBitStopProgressThread) {

          done = true;

        }

      } else {

        uint64_t progress_id = 0;

        uint64_t completed = 0;

        uint64_t total = 0;

        bool is_debugger_specific = false;

        const char *message = lldb::SBDebugger::GetProgressFromEvent(

            event, progress_id, completed, total, is_debugger_specific);

        if (message)

          g_vsc.SendProgressEvent(progress_id, message, completed, total);

      }

    }

  }

}

// 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

// is required.

void EventThreadFunction() {

  lldb::SBEvent event;

  lldb::SBListener listener = g_vsc.debugger.GetListener();

  bool done = false;

  while (!done) {

    if (listener.WaitForEvent(1, event)) {

      const auto event_mask = event.GetType();

      if (lldb::SBProcess::EventIsProcessEvent(event)) {

        lldb::SBProcess process = lldb::SBProcess::GetProcessFromEvent(event);

        if (event_mask & lldb::SBProcess::eBroadcastBitStateChanged) {

          auto state = lldb::SBProcess::GetStateFromEvent(event);

          switch (state) {

          case lldb::eStateInvalid:

            // Not a state event

            break;

          case lldb::eStateUnloaded:

            break;

          case lldb::eStateConnected:

            break;

          case lldb::eStateAttaching:

            break;

          case lldb::eStateLaunching:

            break;

          case lldb::eStateStepping:

            break;

          case lldb::eStateCrashed:

            break;

          case lldb::eStateDetached:

            break;

          case lldb::eStateSuspended:

            break;

          case lldb::eStateStopped:

            // We launch and attach in synchronous mode then the first stop

            // event will not be delivered. If we use "launchCommands" during a

            // launch or "attachCommands" during an attach we might some process

            // stop events which we do not want to send an event for. We will

            // manually send a stopped event in request_configurationDone(...)

            // so don't send any before then.

            if (g_vsc.configuration_done_sent) {

              // Only report a stopped event if the process was not

              // automatically restarted.

              if (!lldb::SBProcess::GetRestartedFromEvent(event)) {

                SendStdOutStdErr(process);

                SendThreadStoppedEvent();

              }

            }

            break;

          case lldb::eStateRunning:

            g_vsc.WillContinue();

            SendContinuedEvent();

            break;

          case lldb::eStateExited:

            // When restarting, we can get an "exited" event for the process we

            // just killed with the old PID, or even with no PID. In that case

            // we don't have to terminate the session.

            if (process.GetProcessID() == LLDB_INVALID_PROCESS_ID ||

                process.GetProcessID() == g_vsc.restarting_process_id) {

              g_vsc.restarting_process_id = LLDB_INVALID_PROCESS_ID;

            } else {

              // Run any exit LLDB commands the user specified in the

              // launch.json

              g_vsc.RunExitCommands();

              SendProcessExitedEvent(process);

              SendTerminatedEvent();

              done = true;

            }

            break;

          }

        } else 
if (2
(event_mask & lldb::SBProcess::eBroadcastBitSTDOUT)2
 ||

                   
(event_mask & lldb::SBProcess::eBroadcastBitSTDERR)0
) {

          SendStdOutStdErr(process);

        }

      } else 
if (2
lldb::SBBreakpoint::EventIsBreakpointEvent(event)2
) {

        if (event_mask & lldb::SBTarget::eBroadcastBitBreakpointChanged) {

          auto event_type =

              lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent(event);

          auto bp = lldb::SBBreakpoint::GetBreakpointFromEvent(event);

          // If the breakpoint was originated from the IDE, it will have the

          // BreakpointBase::GetBreakpointLabel() label attached. Regardless

          // of wether the locations were added or removed, the breakpoint

          // ins't going away, so we the reason is always "changed".

          if ((event_type & lldb::eBreakpointEventTypeLocationsAdded ||

               event_type & lldb::eBreakpointEventTypeLocationsRemoved) &&

              
bp.MatchesName(BreakpointBase::GetBreakpointLabel())0
) {

            auto bp_event = CreateEventObject("breakpoint");

            llvm::json::Object body;

            // As VSCode already knows the path of this breakpoint, we don't

            // need to send it back as part of a "changed" event. This

            // prevent us from sending to VSCode paths that should be source

            // mapped. Note that CreateBreakpoint doesn't apply source mapping.

            // Besides, the current implementation of VSCode ignores the

            // "source" element of breakpoint events.

            llvm::json::Value source_bp = CreateBreakpoint(bp);

            source_bp.getAsObject()->erase("source");

            body.try_emplace("breakpoint", source_bp);

            body.try_emplace("reason", "changed");

            bp_event.try_emplace("body", std::move(body));

            g_vsc.SendJSON(llvm::json::Value(std::move(bp_event)));

          }

        }

      } else 
if (0
event.BroadcasterMatchesRef(g_vsc.broadcaster)0
) {

        if (event_mask & eBroadcastBitStopEventThread) {

          done = true;

        }

      }

    }

  }

}

// Both attach and launch take a either a sourcePath or sourceMap

// argument (or neither), from which we need to set the target.source-map.

void SetSourceMapFromArguments(const llvm::json::Object &arguments) {

  const char *sourceMapHelp =

      "source must be be an array of two-element arrays, "

      "each containing a source and replacement path string.\n";

  std::string sourceMapCommand;

  llvm::raw_string_ostream strm(sourceMapCommand);

  strm << "settings set target.source-map ";

  auto sourcePath = GetString(arguments, "sourcePath");

  // sourceMap is the new, more general form of sourcePath and overrides it.

  auto sourceMap = arguments.getArray("sourceMap");

  if (sourceMap) {

    for (const auto &value : *sourceMap) {

      auto mapping = value.getAsArray();

      if (mapping == nullptr || mapping->size() != 2 ||

          (*mapping)[0].kind() != llvm::json::Value::String ||

          (*mapping)[1].kind() != llvm::json::Value::String) {

        g_vsc.SendOutput(OutputType::Console, llvm::StringRef(sourceMapHelp));

        return;

      }

      auto mapFrom = GetAsString((*mapping)[0]);

      auto mapTo = GetAsString((*mapping)[1]);

      strm << "\"" << mapFrom << "\" \"" << mapTo << "\" ";

    }

  } else {

    if (ObjectContainsKey(arguments, "sourceMap")) {

      g_vsc.SendOutput(OutputType::Console, llvm::StringRef(sourceMapHelp));

      return;

    }

    if (sourcePath.empty())

      return;

    // Do any source remapping needed before we create our targets

    strm << "\".\" \"" << sourcePath << "\"";

  }

  strm.flush();

  if (!sourceMapCommand.empty()) {

    g_vsc.RunLLDBCommands("Setting source map:", {sourceMapCommand});

  }

}

// "AttachRequest": {

//   "allOf": [ { "$ref": "#/definitions/Request" }, {

//     "type": "object",

//     "description": "Attach request; value of command field is 'attach'.",

//     "properties": {

//       "command": {

//         "type": "string",

//         "enum": [ "attach" ]

//       },

//       "arguments": {

//         "$ref": "#/definitions/AttachRequestArguments"

//       }

//     },

//     "required": [ "command", "arguments" ]

//   }]

// },

// "AttachRequestArguments": {

//   "type": "object",

//   "description": "Arguments for 'attach' request.\nThe attach request has no

//   standardized attributes."

// },

// "AttachResponse": {

//   "allOf": [ { "$ref": "#/definitions/Response" }, {

//     "type": "object",

//     "description": "Response to 'attach' request. This is just an

//     acknowledgement, so no body field is required."

//   }]

// }

void request_attach(const llvm::json::Object &request) {

  g_vsc.is_attach = true;

  g_vsc.last_launch_or_attach_request = request;

  llvm::json::Object response;

  lldb::SBError error;

  FillResponse(request, response);

  lldb::SBAttachInfo attach_info;

  auto arguments = request.getObject("arguments");

  const lldb::pid_t pid =

      GetUnsigned(arguments, "pid", LLDB_INVALID_PROCESS_ID);

  if (pid != LLDB_INVALID_PROCESS_ID)

    attach_info.SetProcessID(pid);

  const auto wait_for = GetBoolean(arguments, "waitFor", false);

  attach_info.SetWaitForLaunch(wait_for, false /*async*/);

  g_vsc.init_commands = GetStrings(arguments, "initCommands");

  g_vsc.pre_run_commands = GetStrings(arguments, "preRunCommands");

  g_vsc.stop_commands = GetStrings(arguments, "stopCommands");

  g_vsc.exit_commands = GetStrings(arguments, "exitCommands");

  g_vsc.terminate_commands = GetStrings(arguments, "terminateCommands");

  auto attachCommands = GetStrings(arguments, "attachCommands");

  llvm::StringRef core_file = GetString(arguments, "coreFile");

  const uint64_t timeout_seconds = GetUnsigned(arguments, "timeout", 30);

  g_vsc.stop_at_entry =

      core_file.empty() ? GetBoolean(arguments, "stopOnEntry", false) : true;

  std::vector<std::string> postRunCommands =

      GetStrings(arguments, "postRunCommands");

  const llvm::StringRef debuggerRoot = GetString(arguments, "debuggerRoot");

  g_vsc.enable_auto_variable_summaries =

      GetBoolean(arguments, "enableAutoVariableSummaries", false);

  g_vsc.enable_synthetic_child_debugging =

      GetBoolean(arguments, "enableSyntheticChildDebugging", false);

  // This is a hack for loading DWARF in .o files on Mac where the .o files

  // in the debug map of the main executable have relative paths which require

  // the lldb-vscode binary to have its working directory set to that relative

  // root for the .o files in order to be able to load debug info.

  if (!debuggerRoot.empty())

    llvm::sys::fs::set_current_path(debuggerRoot);

  // Run any initialize LLDB commands the user specified in the launch.json

  g_vsc.RunInitCommands();

  SetSourceMapFromArguments(*arguments);

  lldb::SBError status;

  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;

  }

  // Run any pre run LLDB commands the user specified in the launch.json

  g_vsc.RunPreRunCommands();

  if (pid == LLDB_INVALID_PROCESS_ID && wait_for) {

    char attach_msg[256];

    auto attach_msg_len = snprintf(attach_msg, sizeof(attach_msg),

                                   "Waiting to attach to \"%s\"...",

                                   g_vsc.target.GetExecutable().GetFilename());

    g_vsc.SendOutput(OutputType::Console,

                     llvm::StringRef(attach_msg, attach_msg_len));

  }

  if (attachCommands.empty()) {

    // No "attachCommands", just attach normally.

    // Disable async events so the attach will be successful when we return from

    // the launch call and the launch will happen synchronously

    g_vsc.debugger.SetAsync(false);

    if (core_file.empty())

      g_vsc.target.Attach(attach_info, error);

    else

      g_vsc.target.LoadCore(core_file.data(), error);

    // Reenable async events

    g_vsc.debugger.SetAsync(true);

  } else {

    // We have "attachCommands" that are a set of commands that are expected

    // to execute the commands after which a process should be created. If there

    // is no valid process after running these commands, we have failed.

    g_vsc.RunLLDBCommands("Running attachCommands:", attachCommands);

    // 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();

    // Make sure the process is attached and stopped before proceeding as the

    // the launch commands are not run using the synchronous mode.

    error = g_vsc.WaitForProcessToStop(timeout_seconds);

  }

  if (error.Success() && core_file.empty()) {

    auto attached_pid = g_vsc.target.GetProcess().GetProcessID();

    if (attached_pid == LLDB_INVALID_PROCESS_ID) {

      if (attachCommands.empty())

        error.SetErrorString("failed to attach to a process");

      else

        error.SetErrorString("attachCommands failed to attach to a process");

    }

  }

  if (error.Fail()) {

    response["success"] = llvm::json::Value(false);

    EmplaceSafeString(response, "message", std::string(error.GetCString()));

  } else {

    g_vsc.RunLLDBCommands("Running postRunCommands:", postRunCommands);

  }

  g_vsc.SendJSON(llvm::json::Value(std::move(response)));

  if (error.Success()) {

    SendProcessEvent(Attach);

    g_vsc.SendJSON(CreateEventObject("initialized"));

  }

}

// "ContinueRequest": {

//   "allOf": [ { "$ref": "#/definitions/Request" }, {

//     "type": "object",

//     "description": "Continue request; value of command field is 'continue'.

//                     The request starts the debuggee to run again.",

//     "properties": {

//       "command": {

//         "type": "string",

//         "enum": [ "continue" ]

//       },

//       "arguments": {

//         "$ref": "#/definitions/ContinueArguments"

//       }

//     },

//     "required": [ "command", "arguments"  ]

//   }]

// },

// "ContinueArguments": {

//   "type": "object",

//   "description": "Arguments for 'continue' request.",

//   "properties": {

//     "threadId": {

//       "type": "integer",

//       "description": "Continue execution for the specified thread (if

//                       possible). If the backend cannot continue on a single

//                       thread but will continue on all threads, it should

//                       set the allThreadsContinued attribute in the response

//                       to true."

//     }

//   },

//   "required": [ "threadId" ]

// },

// "ContinueResponse": {

//   "allOf": [ { "$ref": "#/definitions/Response" }, {

//     "type": "object",

//     "description": "Response to 'continue' request.",

//     "properties": {

//       "body": {

//         "type": "object",

//         "properties": {

//           "allThreadsContinued": {

//             "type": "boolean",

//             "description": "If true, the continue request has ignored the

//                             specified thread and continued all threads

//                             instead. If this attribute is missing a value

//                             of 'true' is assumed for backward

//                             compatibility."

//           }

//         }

//       }

//     },

//     "required": [ "body" ]

//   }]

// }

void request_continue(const llvm::json::Object &request) {

  llvm::json::Object response;

  FillResponse(request, response);

  lldb::SBProcess process = g_vsc.target.GetProcess();

  lldb::SBError error = process.Continue();

  llvm::json::Object body;

  body.try_emplace("allThreadsContinued", true);

  response.try_emplace("body", std::move(body));

  g_vsc.SendJSON(llvm::json::Value(std::move(response)));

}

// "ConfigurationDoneRequest": {

//   "allOf": [ { "$ref": "#/definitions/Request" }, {

//             "type": "object",

//             "description": "ConfigurationDone request; value of command field

//             is 'configurationDone'.\nThe client of the debug protocol must

//             send this request at the end of the sequence of configuration

//             requests (which was started by the InitializedEvent).",

//             "properties": {

//             "command": {

//             "type": "string",

//             "enum": [ "configurationDone" ]

//             },

//             "arguments": {

//             "$ref": "#/definitions/ConfigurationDoneArguments"

//             }

//             },

//             "required": [ "command" ]

//             }]

// },

// "ConfigurationDoneArguments": {

//   "type": "object",

//   "description": "Arguments for 'configurationDone' request.\nThe

//   configurationDone request has no standardized attributes."

// },

// "ConfigurationDoneResponse": {

//   "allOf": [ { "$ref": "#/definitions/Response" }, {

//             "type": "object",

//             "description": "Response to 'configurationDone' request. This is

//             just an acknowledgement, so no body field is required."

//             }]

// },

void request_configurationDone(const llvm::json::Object &request) {

  llvm::json::Object response;

  FillResponse(request, response);

  g_vsc.SendJSON(llvm::json::Value(std::move(response)));

  g_vsc.configuration_done_sent = true;

  if (g_vsc.stop_at_entry)

    SendThreadStoppedEvent();

  else

    g_vsc.target.GetProcess().Continue();

}

// "DisconnectRequest": {

//   "allOf": [ { "$ref": "#/definitions/Request" }, {

//     "type": "object",

//     "description": "Disconnect request; value of command field is

//                     'disconnect'.",

//     "properties": {

//       "command": {

//         "type": "string",

//         "enum": [ "disconnect" ]

//       },

//       "arguments": {

//         "$ref": "#/definitions/DisconnectArguments"

//       }

//     },

//     "required": [ "command" ]

//   }]

// },

// "DisconnectArguments": {

//   "type": "object",

//   "description": "Arguments for 'disconnect' request.",

//   "properties": {

//     "terminateDebuggee": {

//       "type": "boolean",

//       "description": "Indicates whether the debuggee should be terminated

//                       when the debugger is disconnected. If unspecified,

//                       the debug adapter is free to do whatever it thinks

//                       is best. A client can only rely on this attribute

//                       being properly honored if a debug adapter returns

//                       true for the 'supportTerminateDebuggee' capability."

//     },

//     "restart": {

//       "type": "boolean",

//       "description": "Indicates whether the debuggee should be restart

//                       the process."

//     }

//   }

// },

// "DisconnectResponse": {

//   "allOf": [ { "$ref": "#/definitions/Response" }, {

//     "type": "object",

//     "description": "Response to 'disconnect' request. This is just an

//                     acknowledgement, so no body field is required."

//   }]

// }

void request_disconnect(const llvm::json::Object &request) {

  llvm::json::Object response;

  FillResponse(request, response);

  auto arguments = request.getObject("arguments");

  bool defaultTerminateDebuggee = g_vsc.is_attach ? 
false0
 : true;

  bool terminateDebuggee =

      GetBoolean(arguments, "terminateDebuggee", defaultTerminateDebuggee);

  lldb::SBProcess process = g_vsc.target.GetProcess();

  auto state = process.GetState();

  switch (state) {

  case lldb::eStateInvalid:

  case lldb::eStateUnloaded:

  case lldb::eStateDetached:

  case lldb::eStateExited:

    break;

  case lldb::eStateConnected:

  case lldb::eStateAttaching:

  case lldb::eStateLaunching:

  case lldb::eStateStepping:

  case lldb::eStateCrashed:

  case lldb::eStateSuspended:

  case lldb::eStateStopped:

  case lldb::eStateRunning:

    g_vsc.debugger.SetAsync(false);

    lldb::SBError error = terminateDebuggee ? process.Kill() : 
process.Detach()0
;

    if (!error.Success())

      response.try_emplace("error", error.GetCString());

    g_vsc.debugger.SetAsync(true);

    break;

  }

  SendTerminatedEvent();

  g_vsc.SendJSON(llvm::json::Value(std::move(response)));

  if (g_vsc.event_thread.joinable()) {

    g_vsc.broadcaster.BroadcastEventByType(eBroadcastBitStopEventThread);

    g_vsc.event_thread.join();

  }

  if (g_vsc.progress_event_thread.joinable()) {

    g_vsc.broadcaster.BroadcastEventByType(eBroadcastBitStopProgressThread);

    g_vsc.progress_event_thread.join();

  }

}

void request_exceptionInfo(const llvm::json::Object &request) {

  llvm::json::Object response;

  FillResponse(request, response);

  auto arguments = request.getObject("arguments");

  llvm::json::Object body;

  lldb::SBThread thread = g_vsc.GetLLDBThread(*arguments);

  if (thread.IsValid()) {

    auto stopReason = thread.GetStopReason();

    if (stopReason == lldb::eStopReasonSignal)

      body.try_emplace("exceptionId", "signal");

    else if (stopReason == lldb::eStopReasonBreakpoint) {

      ExceptionBreakpoint *exc_bp = g_vsc.GetExceptionBPFromStopReason(thread);

      if (exc_bp) {

        EmplaceSafeString(body, "exceptionId", exc_bp->filter);

        EmplaceSafeString(body, "description", exc_bp->label);

      } else {

        body.try_emplace("exceptionId", "exception");

      }

    } else {

      body.try_emplace("exceptionId", "exception");

    }

    if (!ObjectContainsKey(body, "description")) {

      char description[1024];

      if (thread.GetStopDescription(description, sizeof(description))) {

        EmplaceSafeString(body, "description", std::string(description));

      }

    }

    body.try_emplace("breakMode", "always");

    // auto excInfoCount = thread.GetStopReasonDataCount();

    // for (auto i=0; i<excInfoCount; ++i) {

    //   uint64_t exc_data = thread.GetStopReasonDataAtIndex(i);

    // }

  } else {

    response["success"] = llvm::json::Value(false);

  }

  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.",

//     "properties": {

//       "command": {

//         "type": "string",

//         "enum": [ "completions" ]

//       },

//       "arguments": {

//         "$ref": "#/definitions/CompletionsArguments"

//       }

//     },

//     "required": [ "command", "arguments"  ]

//   }]

// },

// "CompletionsArguments": {

//   "type": "object",