[lldb/Lua] Implement a Simple Lua Script Interpreter Prototype

[JDevlieghere]

Summary

This implements a very elementary Lua script interpreter. It supports running a single command as well as running interactively. It uses editline if available. It's still missing a bunch of stuff though. Some things that I intentionally ingored for now are that I/O isn't properly hooked up (so every print goes to stdout) and the non-editline support which is not handling a bunch of corner cases. The latter is a matter of reusing existing code in the Python interpreter.

Discussion on the mailing list: http://lists.llvm.org/pipermail/lldb-dev/2019-December/015812.html

[xiaobai]

lldb/source/Plugins/ScriptInterpreter/Lua/CMakeLists.txt

10

Nit: I would use target_include_directories here.

https://cmake.org/cmake/help/latest/command/target_include_directories.html

[labath]

It looks like this patch already includes some non-trivial functionality, so I think this is a good time to start figuring out how to test this. Another thing, which may not be needed straight away, but which I think we should consider pretty early is creating some sort of c++ wrappers, similar to the PythonDataObject we have for python. This is so that we don't have C error handling code everywhere, but have things wrapped in a nicer interface with llvm::Expecteds and everything.

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.cpp

47

How much of this class is boiler plate? Can it be shared with something?

159

TBH, I am not sure how useful this error really is. Presumably you will get some sort of an error from the lua interpreter if you just let this pass..

167

So what happens when command is not null terminated? I guess you ought to split this into luaL_loadbuffer && lua_pcall..

171

same here. You can just use AppendErrorWithFormatv..

[JDevlieghere]

Reuse IOHandlerEditline

[JDevlieghere]

• Rebase
• Hide C calls behind C++ abstraction
• Improve error handling
• Add unit test

[JDevlieghere]

• Rebase
• Add test case

[labath]

This is starting to look pretty good. I think that pretty soon you'll have to come up with some way of having a more persistent lua context (instead of creating a fresh one for each command), but that doesn't have to happen now.

Does the "multiline" script command do anything already? Is there anything to test with respect to that.

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.cpp

19–21

No longer needed?

25

it doesn't look like this is used (but if it is, it would be better off as a regular variable)

57

The constructor initialized this member, and the desctructor asserts it to be not null. It doesn't look like this assignment here is actually helping anything..

72

*GetOutputStreamFileSP() << llvm::toString(std::move(error))

76

delete

192

This if is not needed (new always succeeds)

lldb/unittests/ScriptInterpreter/Lua/LuaTests.cpp

53 ↗

(On Diff #234637)

I'm not actually opposed to this (and it's nice to know that this could work if we need it), but why do this as a unit test? It seems like this could be tested equally well with a script command through the lldb driver. I was imagining the unit tests would be most useful for the lower level functionality -- roughly corresponding to the Lua class. Right now that class is pretty simple and doesn't really need a unit test, but I expect it will become more complex over time...

[JDevlieghere]

• Rebase
• Feedback Pavel

lldb/unittests/ScriptInterpreter/Lua/LuaTests.cpp

53 ↗

(On Diff #234637)

Yes, I just wanted to show that it's possible :-) I've also included a test for the Lua class.

[labath]

lldb/unittests/ScriptInterpreter/Lua/CMakeLists.txt

14–15 ↗

(On Diff #234798)

I think you wouldn't need these if the other CMakeLists file would use PUBLIC keyword for headers, and INTERFACE for libraries.

lldb/unittests/ScriptInterpreter/Lua/LuaTests.cpp

53 ↗

(On Diff #234637)

Ok, that's cool.

lldb/include/lldb/Core/IOHandler.h

enum class Type {
     CommandInterpreter,
     CommandList,
     Confirm,
     Curses,
     Expression,
     REPL,
     ProcessIO,
     PythonInterpreter,
+    LuaInterpreter,
     PythonCode,
     Other
   };
 
   IOHandler(Debugger &debugger, IOHandler::Type type);
 
   IOHandler(Debugger &debugger, IOHandler::Type type,
             const lldb::FileSP &input_sp, const lldb::StreamFileSP &output_sp,

lldb/source/Plugins/ScriptInterpreter/Lua/CMakeLists.txt

 add_lldb_library(lldbPluginScriptInterpreterLua PLUGIN
   ScriptInterpreterLua.cpp
 
   LINK_LIBS
     lldbCore
     lldbInterpreter
-  )
+  )
+
+find_package(Lua REQUIRED)
+include_directories(${LUA_INCLUDE_DIR})
+
+target_link_libraries(lldbPluginScriptInterpreterLua PRIVATE ${LUA_LIBRARIES})

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.cpp

 //===-- ScriptInterpreterLua.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 "ScriptInterpreterLua.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StringList.h"
-
+#include "lldb/Utility/Timer.h"
 #include "llvm/Support/Threading.h"
 
+#ifndef LLDB_DISABLE_LIBEDIT
+#include "lldb/Host/Editline.h"
+#endif
+
+#include "lua.hpp"
+
 #include <mutex>
 
 using namespace lldb;
 using namespace lldb_private;
 
+class Lua {
+public:
+  Lua() : m_lua_state(luaL_newstate()) {
+    assert(m_lua_state);
+    luaL_openlibs(m_lua_state);
+  }
+  ~Lua() {
+    assert(m_lua_state);
+    luaL_openlibs(m_lua_state);
+  }
+
+  lua_State *State() { return m_lua_state; }
+
+private:
+  lua_State *m_lua_state = nullptr;
+};
+
+class IOHandlerLuaInterpreter : public IOHandler {
+public:
+  IOHandlerLuaInterpreter(Debugger &debugger, ScriptInterpreterLua *lua)
+      : IOHandler(debugger, IOHandler::Type::LuaInterpreter), m_lua(lua) {
+#ifndef LLDB_DISABLE_LIBEDIT
+
+    bool use_editline = GetInputFILE() && GetOutputFILE() && GetErrorFILE() &&
+                        m_input_sp && m_input_sp->GetIsRealTerminal();
+    if (use_editline) {
+      m_editline_up.reset(new Editline("lua", GetInputFILE(), GetOutputFILE(),
+                                       GetErrorFILE(),
+                                       m_debugger.GetUseColor()));
+      m_editline_up->SetPrompt(">>> ");
+    }
+#endif
+  }
+
+  ~IOHandlerLuaInterpreter() override {}
+
+  void PrintPrompt() { fprintf(GetOutputFILE(), ">>> "); }
+
+  bool GetLine(std::string &line, bool &interrupted) {
+#ifndef LLDB_DISABLE_LIBEDIT
+    if (m_editline_up)
+      return m_editline_up->GetLine(line, interrupted);
+#endif
+
+    PrintPrompt();
+    char buffer[512];
+    char *r = fgets(buffer, sizeof(buffer), GetInputFILE());
+    line = std::string(buffer);
+    return r != nullptr;
+  }
+
+  void Run() override {
+    if (!m_lua) {
+      SetIsDone(true);
+      return;
+    }
+
+    int stdin_fd = GetInputFD();
+    if (stdin_fd < 0) {
+      SetIsDone(true);
+      return;
+    }
+
+    Terminal terminal(stdin_fd);
+    TerminalState terminal_state;
+    const bool is_a_tty = terminal.IsATerminal();
+
+    if (is_a_tty) {
+      terminal_state.Save(stdin_fd, false);
+      terminal.SetCanonical(false);
+      terminal.SetEcho(true);
+    }
+
+    Lua l;
+    std::string line;
+    bool interrupted = false;
+    int error = 0;
+    while (IsActive()) {
+      if (GetLine(line, interrupted)) {
+        error = luaL_loadbuffer(l.State(), line.c_str(), line.size(), "line") ||
+                lua_pcall(l.State(), 0, 0, 0);
+        if (error) {
+          fprintf(GetOutputFILE(), "%s\n", lua_tostring(l.State(), -1));
+          // Pop error message from the stack.
+          lua_pop(l.State(), 1);
+        }
+      } else {
+        SetIsDone(true);
+        break;
+      }
+    }
+
+    if (is_a_tty)
+      terminal_state.Restore();
+
+    SetIsDone(true);
+  }
+
+  void Cancel() override {
+#ifndef LLDB_DISABLE_LIBEDIT
+    if (m_editline_up)
+      m_editline_up->Cancel();
+#endif
+  }
+
+  bool Interrupt() override { return m_lua->Interrupt(); }
+
+  void GotEOF() override {
+#ifndef LLDB_DISABLE_LIBEDIT
+    if (m_editline_up)
+      m_editline_up->Interrupt();
+#endif
+  }
+
+protected:
+#ifndef LLDB_DISABLE_LIBEDIT
+  std::unique_ptr<Editline> m_editline_up;
+#endif
+  ScriptInterpreterLua *m_lua;
+};
+
 ScriptInterpreterLua::ScriptInterpreterLua(Debugger &debugger)
     : ScriptInterpreter(debugger, eScriptLanguageLua) {}
 
 ScriptInterpreterLua::~ScriptInterpreterLua() {}
 
 bool ScriptInterpreterLua::ExecuteOneLine(llvm::StringRef command,
-                                          CommandReturnObject *,
-                                          const ExecuteScriptOptions &) {
-  m_debugger.GetErrorStream().PutCString(
-      "error: the lua script interpreter is not yet implemented.\n");
+                                          CommandReturnObject *result,
+                                          const ExecuteScriptOptions &options) {
+  if (command.empty()) {
+    result->AppendError("empty command passed to lua\n");
+    return false;
+  }
+
+  Lua l;
+
+  // FIXME: Redirecting stdin, stdout and stderr.
+  int success = luaL_dostring(l.State(), command.data());
+  if (success == 0)
+    return true;
+
+  result->AppendErrorWithFormat("lua failed attempting to evaluate '%s'\n",
+                                command.data());
   return false;
 }
 
 void ScriptInterpreterLua::ExecuteInterpreterLoop() {
-  m_debugger.GetErrorStream().PutCString(
-      "error: the lua script interpreter is not yet implemented.\n");
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
+
+  Debugger &debugger = m_debugger;
+
+  // At the moment, the only time the debugger does not have an input file
+  // handle is when this is called directly from lua, in which case it is
+  // both dangerous and unnecessary (not to mention confusing) to try to embed
+  // a running interpreter loop inside the already running lua interpreter
+  // loop, so we won't do it.
+
+  if (!debugger.GetInputFile().IsValid())
+    return;
+
+  IOHandlerSP io_handler_sp(new IOHandlerLuaInterpreter(debugger, this));
+  if (io_handler_sp) {
+    debugger.PushIOHandler(io_handler_sp);
+  }
 }
 
 void ScriptInterpreterLua::Initialize() {
   static llvm::once_flag g_once_flag;
 
   llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(),