ardupilot/libraries/AP_Scripting/lua_repl.cpp

265 lines
8.2 KiB
C++

// this implements a Lua REPL, and is based off of a cut down version of
// lua/src/lua.c. It overall modified the functions to the minimum amount
// required, with the exception of fixing whitespace/indentation on if's
#include "AP_Scripting_config.h"
#if AP_SCRIPTING_ENABLED
#include "lua_scripts.h"
#include <AP_Scripting/lua_generated_bindings.h>
#include "lua/src/lua.h"
#include "lua/src/lauxlib.h"
#include "lua/src/lualib.h"
#include <AP_Logger/LogStructure.h>
#if !defined(LUA_MAXINPUT)
#define LUA_MAXINPUT 256
#endif
#if !defined(LUA_PROMPT)
#define LUA_PROMPT "> "
#define LUA_PROMPT2 ">> "
#endif
extern const AP_HAL::HAL& hal;
/*
** Message handler used to run all chunks
*/
static int msghandler(lua_State *L) {
const char *msg = lua_tostring(L, 1);
if (msg == NULL) { /* is error object not a string? */
if (luaL_callmeta(L, 1, "__tostring") && /* does it have a metamethod */
lua_type(L, -1) == LUA_TSTRING) { /* that produces a string? */
return 1; /* that is the message */
} else {
msg = lua_pushfstring(L, "(error object is a %s value)",
luaL_typename(L, 1));
}
}
luaL_traceback(L, L, msg, 1); /* append a standard traceback */
return 1; /* return the traceback */
}
/*
** Interface to 'lua_pcall', which sets appropriate message function
** and C-signal handler. Used to run all chunks.
*/
int lua_scripts::docall(lua_State *L, int narg, int nres) const {
int status;
int base = lua_gettop(L) - narg; /* function index */
lua_rawgeti(L, LUA_REGISTRYINDEX, sandbox_ref);
lua_setupvalue(L, -2, 1);
lua_pushcfunction(L, msghandler); /* push message handler */
lua_insert(L, base); /* put it under function and args */
status = lua_pcall(L, narg, nres, base);
lua_remove(L, base); /* remove message handler from the stack */
return status;
}
/*
** Returns the string to be used as a prompt by the interpreter.
*/
const char * lua_scripts::get_prompt(lua_State *L, int firstline) {
const char *p;
lua_getglobal(L, firstline ? "_PROMPT" : "_PROMPT2");
p = lua_tostring(L, -1);
if (p == NULL) {
p = (firstline ? LUA_PROMPT : LUA_PROMPT2);
}
return p;
}
/* mark in error messages for incomplete statements */
#define EOFMARK "<eof>"
#define marklen (sizeof(EOFMARK)/sizeof(char) - 1)
/*
** Check whether 'status' signals a syntax error and the error
** message at the top of the stack ends with the above mark for
** incomplete statements.
*/
int lua_scripts::incomplete(lua_State *L, int status) {
if (status == LUA_ERRSYNTAX) {
size_t lmsg;
const char *msg = lua_tolstring(L, -1, &lmsg);
if (lmsg >= marklen && strcmp(msg + lmsg - marklen, EOFMARK) == 0) {
lua_pop(L, 1);
return 1;
}
}
return 0; /* else... */
}
/*
** Prompt the user, read a line, and push it into the Lua stack.
*/
int lua_scripts::pushline(lua_State *L, int firstline) {
char buffer[LUA_MAXINPUT + 1] = {};
size_t l = 0;
// send prompt to the user
terminal_print(get_prompt(L, firstline));
while (terminal.session) {
// reseek to where we need input from, as invalid reads could have done weird stuff, and we want to start from the last valid input
int input_fd = AP::FS().open(REPL_IN, O_RDONLY);
if (input_fd != -1) {
AP::FS().lseek(input_fd, terminal.input_offset, SEEK_SET);
ssize_t read_bytes = AP::FS().read(input_fd, buffer, ARRAY_SIZE(buffer) - 1);
AP::FS().close(input_fd);
if (read_bytes > 0) {
// locate the first newline
char * newline_chr = strchr(buffer, '\n');
if (newline_chr != NULL) {
newline_chr[0] = '\0';
// only advance to the newline
l = strlen(buffer);
terminal.input_offset += l + 1;
break;
}
}
}
// wait for any input
hal.scheduler->delay(100);
}
lua_pop(L, 1); /* remove prompt */
lua_pushlstring(L, buffer, l);
return 1;
}
/*
** Try to compile line on the stack as 'return <line>;'; on return, stack
** has either compiled chunk or original line (if compilation failed).
*/
int lua_scripts::addreturn(lua_State *L) {
const char *line = lua_tostring(L, -1); /* original line */
const char *retline = lua_pushfstring(L, "return %s;", line);
int status = luaL_loadbuffer(L, retline, strlen(retline), "=stdin");
if (status == LUA_OK) {
lua_remove(L, -2); /* remove modified line */
} else {
lua_pop(L, 2); /* pop result from 'luaL_loadbuffer' and modified line */
}
return status;
}
/*
** Read multiple lines until a complete Lua statement
*/
int lua_scripts::multiline (lua_State *L) {
for (;;) { /* repeat until gets a complete statement */
size_t len;
const char *line = lua_tolstring(L, 1, &len); /* get what it has */
int status = luaL_loadbuffer(L, line, len, "=stdin"); /* try it */
if (!incomplete(L, status) || !pushline(L, 0)) {
return status; /* cannot or should not try to add continuation line */
}
lua_pushliteral(L, "\n"); /* add newline... */
lua_insert(L, -2); /* ...between the two lines */
lua_concat(L, 3); /* join them */
}
}
/*
** Read a line and try to load (compile) it first as an expression (by
** adding "return " in front of it) and second as a statement. Return
** the final status of load/call with the resulting function (if any)
** in the top of the stack.
*/
int lua_scripts::loadline(lua_State *L) {
int status;
lua_settop(L, 0);
if (!pushline(L, 1)) {
return -1; /* no input */
}
if ((status = addreturn(L)) != LUA_OK) { /* 'return ...' did not work? */
status = multiline(L); /* try as command, maybe with continuation lines */
} else {
}
lua_remove(L, 1); /* remove line from the stack */
lua_assert(lua_gettop(L) == 1);
return status;
}
// push the tring into the terminal, blocks until it's queued
void lua_scripts::terminal_print(const char *str) {
if ((AP::FS().write(terminal.output_fd, str, strlen(str)) == -1) ||
(AP::FS().fsync(terminal.output_fd) != 0)) {
terminal.session = false;
}
}
/*
** Prints (calling the Lua 'print' function) any values on the stack
*/
void lua_scripts::l_print(lua_State *L) {
int n = lua_gettop(L);
if (n > 0) { /* any result to be printed? */
luaL_checkstack(L, LUA_MINSTACK, "too many results to print");
// grab all the internal functions via the sandbox
lua_rawgeti(L, LUA_REGISTRYINDEX, sandbox_ref);
lua_getfield(L, -1, "string");
lua_getfield(L, -1, "format");
lua_insert(L, 1);
lua_remove(L, -2);
lua_getfield(L, -1, "rep");
lua_remove(L, -2);
lua_pushliteral(L, "%s");
lua_pushinteger(L, n);
lua_pushliteral(L, "\t");
if (lua_pcall(L, 3, 1, 0) != LUA_OK) {
// should never happen
lua_error(L);
}
lua_insert(L, 2);
if (lua_pcall(L, n + 1, 1, 0) != LUA_OK) {
terminal_print(lua_pushfstring(L, "error calling 'print' (%s)\n", lua_tostring(L, -1)));
} else {
terminal_print(lua_pushfstring(L, "%s\n", lua_tostring(L, -1)));
}
}
}
/*
** Do the REPL: repeatedly read (load) a line, evaluate (call) it, and
** print any results.
*/
void lua_scripts::doREPL(lua_State *L) {
int status;
// clear out any old script results
reset_loop_overtime(L);
// prep the sandbox
create_sandbox(L);
sandbox_ref = luaL_ref(L, LUA_REGISTRYINDEX);
terminal.input_offset = 0;
while (((status = loadline(L)) != -1) && terminal.session) {
if (status == LUA_OK) {
status = docall(L, 0, LUA_MULTRET);
}
if (status == LUA_OK) {
l_print(L);
} else {
terminal_print(lua_pushfstring(L, "%s\n", lua_tostring(L, -1)));
}
reset_loop_overtime(L);
}
lua_settop(L, 0); /* clear stack */
luaL_unref(L, LUA_REGISTRYINDEX, sandbox_ref);
repl_cleanup();
}
#endif // AP_SCRIPTING_ENABLED