WIP -- add CLI to lldb-vscode

[lanza]

😢

lldb/tools/lldb-vscode/VSCode.h

struct VSCode {
   InputStream input;
   OutputStream output;
   lldb::SBDebugger debugger;
   lldb::SBTarget target;
   Variables variables;
   lldb::SBBroadcaster broadcaster;
   std::thread event_thread;
   std::thread progress_event_thread;
+  std::thread command_interpreter_thread;
   std::unique_ptr<std::ofstream> log;
   llvm::DenseMap<lldb::addr_t, int64_t> addr_to_source_ref;
   llvm::DenseMap<int64_t, SourceReference> source_map;
   llvm::StringMap<SourceBreakpointMap> source_breakpoints;
   FunctionBreakpointMap function_breakpoints;
   std::vector<ExceptionBreakpoint> exception_breakpoints;
   std::vector<std::string> init_commands;
   std::vector<std::string> pre_run_commands;

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

 #include <cassert>
 #include <climits>
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <termios.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>
if (sourceMap) {
     strm << "\".\" \"" << sourcePath << "\"";
   }
   strm.flush();
   if (!sourceMapCommand.empty()) {
     g_vsc.RunLLDBCommands("Setting source map:", {sourceMapCommand});
   }
 }
 
+static void reset_stdin_termios();
+static bool g_old_stdin_termios_is_valid = false;
+static struct termios g_old_stdin_termios;
+
+// In the Driver::MainLoop, we change the terminal settings.  This function is
+// added as an atexit handler to make sure we clean them up.
+static void reset_stdin_termios() {
+  if (g_old_stdin_termios_is_valid) {
+    g_old_stdin_termios_is_valid = false;
+    ::tcsetattr(STDIN_FILENO, TCSANOW, &g_old_stdin_termios);
+  }
+}
+
+void CommandInterpreterThreadFunction() {
+  if (::tcgetattr(STDIN_FILENO, &g_old_stdin_termios) == 0) {
+    g_old_stdin_termios_is_valid = true;
+    atexit(reset_stdin_termios);
+  }
+#ifndef _MSC_VER
+  // Disabling stdin buffering with MSVC's 2015 CRT exposes a bug in fgets
+  // which causes it to miss newlines depending on whether there have been an
+  // odd or even number of characters.  Bug has been reported to MS via Connect.
+ ::setbuf(stdin, nullptr);
+#endif
+  ::setbuf(stdout, nullptr);
+  g_vsc.debugger.RunCommandInterpreter(false, false);
+}
+
 // "AttachRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "Attach request; value of command field is 'attach'.",
 //     "properties": {
 //       "command": {
 //         "type": "string",
 //         "enum": [ "attach" ]
void request_disconnect(const llvm::json::Object &request) {
   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();
   }
+
+  if (g_vsc.command_interpreter_thread.joinable())
+    g_vsc.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);

 //     },
 //     "supportsVariablePaging": {
 //       "type": "boolean",
 //       "description": "Client supports the paging of variables."
 //     },
 //     "supportsRunInTerminalRequest": {
 //       "type": "boolean",
 //       "description": "Client supports the runInTerminal request."
+//     },
+//     "supportsCommandInterpreter": {
+//       "type": "boolean",
+//       "description": "Client launches lldb-vscode in a terminal and thus
+//                       supports attaching the CommandInterpreter."
 //     }
 //   },
 //   "required": [ "adapterID" ]
 // },
 // "InitializeResponse": {
 //   "allOf": [ { "$ref": "#/definitions/Response" }, {
 //     "type": "object",
 //     "description": "Response to 'initialize' request.",
 //     "properties": {
 //       "body": {
 //         "$ref": "#/definitions/Capabilities",
 //         "description": "The capabilities of this debug adapter."
 //       }
 //     }
 //   }]
 // }
 void request_initialize(const llvm::json::Object &request) {
   g_vsc.debugger = lldb::SBDebugger::Create(true /*source_init_files*/);
   g_vsc.progress_event_thread = std::thread(ProgressEventThreadFunction);
 
   // Create an empty target right away since we might get breakpoint requests
   // before we are given an executable to launch in a "launch" request, or a
   // executable when attaching to a process by process ID in a "attach"
   // request.
+  //
+  // Start our event thread so we can receive events from the debugger, target,
+  // process and more.
+  g_vsc.event_thread = std::thread(EventThreadFunction);
+
+    // Set the output and error file handles to redirect into nothing iff the
+  // input and output are set to stdin and stdout. If we are receiving DAP
+  // packets over a socket then keep them up. Otherwise if any code in LLDB
+  // prints to the debugger file handles, the output and error file handles are
+  // initialized to STDOUT and STDERR and any output will kill our debug
+  // session.
+  if (!g_vsc.input.descriptor.m_is_socket) {
+    FILE *out = llvm::sys::RetryAfterSignal(nullptr, fopen, dev_null_path, "w");
+    if (out) {
+      g_vsc.debugger.SetOutputFileHandle(out, true);
+      g_vsc.debugger.SetErrorFileHandle(out, false);
+    }
+  }
+
+  // We can't attach the command interpreter if the DAP packets are being sent
+  // via stdin/stdout. We would require extra sockets. So only attach the CI iff
+  // we are communicating via a socket.
+  if (g_vsc.input.descriptor.m_is_socket) {
+    auto arguments = request.getObject("arguments");
+    auto supports_ci =
+        GetBoolean(arguments, "supportsCommandInterpreter", false);
+    if (supports_ci) {
+      g_vsc.command_interpreter_thread =
+          std::thread(CommandInterpreterThreadFunction);
+    }
+  }
+
   FILE *out = llvm::sys::RetryAfterSignal(nullptr, fopen, dev_null_path, "w");
   if (out) {
     // Set the output and error file handles to redirect into nothing otherwise
     // if any code in LLDB prints to the debugger file handles, the output and
     // error file handles are initialized to STDOUT and STDERR and any output
     // will kill our debug session.
     g_vsc.debugger.SetOutputFileHandle(out, true);
     g_vsc.debugger.SetErrorFileHandle(out, false);
   }
 
-  // Start our event thread so we can receive events from the debugger, target,
-  // process and more.
-  g_vsc.event_thread = std::thread(EventThreadFunction);
 
   llvm::json::Object response;
   FillResponse(request, response);
   llvm::json::Object body;
   // The debug adapter supports the configurationDoneRequest.
   body.try_emplace("supportsConfigurationDoneRequest", true);
   // The debug adapter supports function breakpoints.
   body.try_emplace("supportsFunctionBreakpoints", true);