/* ** NodeMCU Lua 5.1 and 5.3 main initiator and comand interpreter ** See Copyright Notice in lua.h */ #include #include #include #include "user_version.h" #include "driver/input.h" #define lua_c #define LUA_CORE #ifndef LUA_VERSION_51 /* LUA_VERSION_NUM == 503 */ #define LUA_VERSION_53 #include "lua.h" #include "lauxlib.h" #include "lualib.h" #include "lprefix.h" #include "lgc.h" #include "lnodemcu.h" #endif #include "platform.h" #if !defined(LUA_PROMPT) #define LUA_PROMPT "> " #define LUA_PROMPT2 ">> " #endif #ifndef LUA_INIT_STRING #define LUA_INIT_STRING "@init.lua" #endif /* ** The NodeMCU version of lua.c is structurally different for standard lua.c ** as a result of architectural drivers arising from its context and being ** initiated within the startup sequence of an IoT SoC embedded runtime. ** ** 1) Processing is based on a single threaded event loop model (somewhat akin ** to Node.js), so access to most system services is asyncronous and uses ** a callback mechanism. The Lua interactive mode processes input lines ** that are provided by the firmware on a line by line basis and indeed ** other Lua tasks might interleave any multiline processing, so the ** standard doREPL approach won't work. ** ** 2) Most OS services and enviroment processing are supported so much of the ** standard functionality is irrelevant and is stripped out for simplicity. ** ** 3) stderr and stdout redirection aren't offered as an OS service, so this ** is handled in the baselib print function and errors are sent to print. */ lua_State *globalL = NULL; static int pmain (lua_State *L); void lua_input_string (const char *line, int len); /* ** Prints (calling the Lua 'print' function) to print n values on the stack */ static void l_print (lua_State *L, int n) { if (n > 0) { /* any result to be printed? */ luaL_checkstack(L, LUA_MINSTACK, "too many results to print"); lua_getglobal(L, "print"); lua_insert(L, -n-1); if (lua_pcall(L, n, 0, 0) != LUA_OK) lua_writestringerror( "error calling 'print' (%s)\n", lua_tostring(L, -1)); } } /* ** Message handler is used with all chunks calls. Returns the traceback on ToS */ 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 */ msg = lua_pushfstring(L, "(error object is a %s value)", luaL_typename(L, 1)); lua_remove(L, -2); /* otherwise swap with printable error */ } #ifdef LUA_VERSION_51 lua_getglobal(L,"debug"); lua_getfield(L, -1,"traceback"); lua_insert(L, 1); /* pass error message */ lua_pop(L, 1); lua_pushinteger(L, 2); /* skip this function and traceback */ lua_call(L, 2, 1); /* call debug.traceback */ #else /* LUA_VERSION_53 */ luaL_traceback(L, L, msg, 1); /* append a standard traceback */ #endif return 1; /* return the traceback */ } /* ** Interface to 'lua_pcall', which sets appropriate message function ** and error handler. Used to run all chunks. */ static int docall (lua_State *L, int narg, int nres) { int status; int base = lua_gettop(L) - narg; /* function index */ lua_pushcfunction(L, msghandler); /* push message handler */ lua_insert(L, base); /* put it under chunk and args */ status = lua_pcall(L, narg, (nres ? 0 : LUA_MULTRET), base); lua_remove(L, base); /* remove message handler from the stack */ /* force a complete garbage collection in case of errors */ if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0); return status; } static void print_version (lua_State *L) { #ifndef DISABLE_STARTUP_BANNER lua_writestringerror( "\n" NODE_VERSION " build " BUILD_DATE " powered by " LUA_RELEASE " on SDK %s\n", SDK_VERSION); #endif } /* ** Returns the string to be used as a prompt by the interpreter. */ static const char *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); lua_pop(L, 1); /* remove global */ return p; } /* ** 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. */ #ifdef LUA_VERSION_51 #define EOFMARK LUA_QL("") #else #define EOFMARK "" #endif #define MARKLEN (sizeof(EOFMARK)/sizeof(char) - 1) static int 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)) { lua_pop(L, 1); return 1; } } return 0; } static void l_create_stdin (lua_State *L); /* ** Note that the Lua stack can't be used to stash part-line components as ** other C API and Lua functions might be executed as tasks between lines in ** a multiline, so a standard luaL_ref() registry entry is used instead. */ //// TODO SHOLD this have an boot return false if pipe empty else nil static void dojob (lua_State *L) { static int MLref = LUA_NOREF; /* Lua Reg entry for cached multi-line */ int status; const char *prompt; size_t l; const char *b = lua_tostring(L, -1); /* ToS contains next input line */ if (MLref != LUA_NOREF) { /* processing multiline */ lua_rawgeti(L, LUA_REGISTRYINDEX, MLref); /* insert prev lines(s) */ lua_pushliteral(L, "\n"); /* insert CR */ lua_pushvalue(L, -3); /* dup new line */ lua_concat(L, 3); /* concat all 3 */ lua_remove(L,-2); /* and shift down to ToS */ } else if (b[0] == '=') { /* If firstline and of the format = */ lua_pushfstring(L, "return %s", b+1); lua_remove(L, -2); } /* * ToS is at S[2] which contains the putative chunk to be compiled */ b = lua_tolstring(L, -1, &l); status = luaL_loadbuffer(L, b, l, "=stdin"); if (incomplete(L, status)) { /* Store line back in the Reg mlref sot */ if (MLref == LUA_NOREF) { MLref = luaL_ref(L, LUA_REGISTRYINDEX); } else { lua_rawseti(L, LUA_REGISTRYINDEX, MLref); } } else { /* compile finished OK or with hard error */ lua_remove(L, -2); /* remove line because now redundant */ if (MLref != LUA_NOREF) { /* also remove multiline if it exists */ luaL_unref(L, LUA_REGISTRYINDEX, MLref); MLref = LUA_NOREF; } /* Execute the compiled chunk of successful */ if (status == 0) status = docall(L, 0, 0); /* print any returned results or error message */ if (status && !lua_isnil(L, -1)) lua_writestringerror("Lua error: %s\n", lua_tostring(L, -1)); if (status == 0 && lua_gettop(L) - 1) l_print(L, lua_gettop(L) - 1); lua_settop(L, 2); if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0); } prompt = get_prompt(L, MLref!= LUA_NOREF ? 0 : 1); input_setprompt(prompt); lua_writestring(prompt,strlen(prompt)); lua_pushnil(L); } /* ** Main body of standalone interpreter. */ static int pmain (lua_State *L) { const char *init = LUA_INIT_STRING; int status; lua_gc(L, LUA_GCSTOP, 0); /* stop GC during initialization */ luaL_openlibs(L); /* Nodemcu open will throw to signal an LFS reload */ #ifdef LUA_VERSION_51 lua_setegcmode( L, EGC_ALWAYS, 4096 ); #else lua_gc( L, LUA_GCSETMEMLIMIT, 4096 ); #endif lua_gc(L, LUA_GCRESTART, 0); /* restart GC and set EGC mode */ lua_settop(L, 0); l_create_stdin(L); input_setup(LUA_MAXINPUT, get_prompt(L, 1)); lua_input_string(" \n", 2); /* queue CR to issue first prompt */ print_version(L); /* * And last of all, kick off application initialisation. Note that if * LUA_INIT_STRING is a file reference and the file system is uninitialised * then attempting the open will trigger a file system format. */ platform_rcr_read(PLATFORM_RCR_INITSTR, (void**) &init); status = (init[0] == '@') ? luaL_loadfile(L, init+1) : luaL_loadbuffer(L, init, strlen(init), "=INIT"); if (status == LUA_OK) status = docall(L, 0, 0); if (status != LUA_OK) l_print (L, 1); return 0; } /* ** The system initialisation CB nodemcu_init() calls lua_main() to startup the ** Lua environment by calling luaL_newstate() which initiates the core Lua VM. ** The initialisation of the libraries, etc. can potentially throw errors and ** so is wrapped in a protected call which also kicks off the user application ** through the LUA_INIT_STRING hook. */ int lua_main (void) { lua_State *L = luaL_newstate(); if (L == NULL) { lua_writestringerror( "cannot create state: %s", "not enough memory"); return 0; } globalL = L; lua_pushcfunction(L, pmain); if (docall(L, 0, 0) != LUA_OK) { if (strstr(lua_tostring(L, -1),"!LFSrestart!")) { lua_close(L); return 1; /* non-zero return to flag LFS reload */ } l_print(L, 1); } return 0; } lua_State *lua_getstate(void) { return globalL; } /* ** The Lua interpreter is event-driven and task-oriented in NodeMCU rather than ** based on a readline poll loop as in the standard implementation. Input lines ** can come from one of two sources: the application can "push" lines for the ** interpreter to compile and execute, or they can come from the UART. To ** minimise application blocking, the lines are queued in a pipe when received, ** with the Lua interpreter task attached to the pipe as its reader task. This ** CB processes one line of input per task execution. ** ** Even though lines can be emitted from independent sources (the UART and the ** node API), and they could in theory get interleaved, the strategy here is ** "let the programmer beware": interactive input will normally only occur in ** development and injected input occur in telnet type applications. If there ** is a need for interlocks, then the application should handle this. */ void lua_input_string (const char *line, int len) { lua_State *L = globalL; lua_getfield(L, LUA_REGISTRYINDEX, "stdin"); lua_rawgeti(L, -1, 1); /* get the pipe_write from stdin[1] */ lua_insert(L, -2); /* stick above the pipe */ lua_pushlstring(L, line, len); lua_call(L, 2, 0); /* stdin:write(line) */ } /* ** CB reader for the stdin pipe, and follows the calling conventions for a ** pipe readers; it has one argument, the stdin pipe that it is reading. */ static int l_read_stdin (lua_State *L) { size_t l; lua_settop(L, 1); /* pipe obj at S[1] */ lua_getfield(L, 1, "read"); /* pobj:read at S[2] */ lua_pushvalue(L, 1); /* dup pobj to S[3] */ lua_pushliteral(L, "\n+"); /* S[4] = "\n+" */ lua_call(L, 2, 1); /* S[2] = pobj:read("\n+") */ const char* b = lua_tolstring(L, 2, &l); /* b = NULL if S[2] is nil */ /* * If the pipe is empty, or the line not CR terminated, return false to * suppress automatic reposting */ lua_pushboolean(L, false); if ((lua_isnil(L, 2) || l == 0)) return 1; /* return false if pipe empty */ if (b[l-1] != '\n') { /* likewise if not CR terminated, then unread and ditto */ lua_getfield(L, 1, "unread"); lua_insert(L, 1); /* insert pipe.unread above the pipe */ lua_call(L, 2, 0); /* pobj:unread(line) */ return 1; /* return false */ } lua_pop(L, 1); /* dump false value at ToS */ /* * Now we can process a proper CR terminated line */ lua_pushlstring(L, b, --l); /* remove end CR */ lua_remove(L, 2); dojob(L); return 0; } /* ** Create and initialise the stdin pipe */ static void l_create_stdin (lua_State *L) { lua_pushliteral(L, "stdin"); lua_getglobal(L, "pipe"); lua_getfield(L, -1, "create"); lua_remove(L, -2); lua_pushcfunction(L, l_read_stdin); lua_pushinteger(L, LUA_TASK_LOW); lua_call(L, 2, 1); /* ToS = pipe.create(dojob, low_priority) */ lua_rawset(L, LUA_REGISTRYINDEX); /* and stash input pipe in Reg["stdin"] */ }