Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  1. /*
  2. ** $Id: lua.c,v 1.160.1.2 2007/12/28 15:32:23 roberto Exp $
  3. ** Lua stand-alone interpreter
  4. ** See Copyright Notice in lua.h
  5. */
  6.  
  7.  
  8. #include <signal.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12.  
  13. #define lua_c
  14.  
  15. #include "lua.h"
  16.  
  17. #include "lauxlib.h"
  18. #include "lualib.h"
  19.  
  20.  
  21.  
  22. static lua_State *globalL = NULL;
  23.  
  24. static const char *progname = LUA_PROGNAME;
  25.  
  26.  
  27.  
  28. static void lstop (lua_State *L, lua_Debug *ar) {
  29.   (void)ar;  /* unused arg. */
  30.   lua_sethook(L, NULL, 0, 0);
  31.   luaL_error(L, "interrupted!");
  32. }
  33.  
  34.  
  35. static void laction (int i) {
  36.   signal(i, SIG_DFL); /* if another SIGINT happens before lstop,
  37.                               terminate process (default action) */
  38.   lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
  39. }
  40.  
  41.  
  42. static void print_usage (void) {
  43.   fprintf(stderr,
  44.   "usage: %s [options] [script [args]].\n"
  45.   "Available options are:\n"
  46.   "  -e stat  execute string " LUA_QL("stat") "\n"
  47.   "  -l name  require library " LUA_QL("name") "\n"
  48.   "  -i       enter interactive mode after executing " LUA_QL("script") "\n"
  49.   "  -v       show version information\n"
  50.   "  --       stop handling options\n"
  51.   "  -        execute stdin and stop handling options\n"
  52.   ,
  53.   progname);
  54.   fflush(stderr);
  55. }
  56.  
  57.  
  58. static void l_message (const char *pname, const char *msg) {
  59.   if (pname) fprintf(stderr, "%s: ", pname);
  60.   fprintf(stderr, "%s\n", msg);
  61.   fflush(stderr);
  62. }
  63.  
  64.  
  65. static int report (lua_State *L, int status) {
  66.   if (status && !lua_isnil(L, -1)) {
  67.     const char *msg = lua_tostring(L, -1);
  68.     if (msg == NULL) msg = "(error object is not a string)";
  69.     l_message(progname, msg);
  70.     lua_pop(L, 1);
  71.   }
  72.   return status;
  73. }
  74.  
  75.  
  76. static int traceback (lua_State *L) {
  77.   if (!lua_isstring(L, 1))  /* 'message' not a string? */
  78.     return 1;  /* keep it intact */
  79.   lua_getfield(L, LUA_GLOBALSINDEX, "debug");
  80.   if (!lua_istable(L, -1)) {
  81.     lua_pop(L, 1);
  82.     return 1;
  83.   }
  84.   lua_getfield(L, -1, "traceback");
  85.   if (!lua_isfunction(L, -1)) {
  86.     lua_pop(L, 2);
  87.     return 1;
  88.   }
  89.   lua_pushvalue(L, 1);  /* pass error message */
  90.   lua_pushinteger(L, 2);  /* skip this function and traceback */
  91.   lua_call(L, 2, 1);  /* call debug.traceback */
  92.   return 1;
  93. }
  94.  
  95.  
  96. static int docall (lua_State *L, int narg, int clear) {
  97.   int status;
  98.   int base = lua_gettop(L) - narg;  /* function index */
  99.   lua_pushcfunction(L, traceback);  /* push traceback function */
  100.   lua_insert(L, base);  /* put it under chunk and args */
  101.   signal(SIGINT, laction);
  102.   status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
  103.   signal(SIGINT, SIG_DFL);
  104.   lua_remove(L, base);  /* remove traceback function */
  105.   /* force a complete garbage collection in case of errors */
  106.   if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
  107.   return status;
  108. }
  109.  
  110.  
  111. static void print_version (void) {
  112.   l_message(NULL, LUA_RELEASE "  " LUA_COPYRIGHT);
  113. }
  114.  
  115.  
  116. static int getargs (lua_State *L, char **argv, int n) {
  117.   int narg;
  118.   int i;
  119.   int argc = 0;
  120.   while (argv[argc]) argc++;  /* count total number of arguments */
  121.   narg = argc - (n + 1);  /* number of arguments to the script */
  122.   luaL_checkstack(L, narg + 3, "too many arguments to script");
  123.   for (i=n+1; i < argc; i++)
  124.     lua_pushstring(L, argv[i]);
  125.   lua_createtable(L, narg, n + 1);
  126.   for (i=0; i < argc; i++) {
  127.     lua_pushstring(L, argv[i]);
  128.     lua_rawseti(L, -2, i - n);
  129.   }
  130.   return narg;
  131. }
  132.  
  133.  
  134. static int dofile (lua_State *L, const char *name) {
  135.   int status = luaL_loadfile(L, name) || docall(L, 0, 1);
  136.   return report(L, status);
  137. }
  138.  
  139.  
  140. static int dostring (lua_State *L, const char *s, const char *name) {
  141.   int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1);
  142.   return report(L, status);
  143. }
  144.  
  145.  
  146. static int dolibrary (lua_State *L, const char *name) {
  147.   lua_getglobal(L, "require");
  148.   lua_pushstring(L, name);
  149.   return report(L, docall(L, 1, 1));
  150. }
  151.  
  152.  
  153. static const char *get_prompt (lua_State *L, int firstline) {
  154.   const char *p;
  155.   lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");
  156.   p = lua_tostring(L, -1);
  157.   if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2);
  158.   lua_pop(L, 1);  /* remove global */
  159.   return p;
  160. }
  161.  
  162.  
  163. static int incomplete (lua_State *L, int status) {
  164.   if (status == LUA_ERRSYNTAX) {
  165.     size_t lmsg;
  166.     const char *msg = lua_tolstring(L, -1, &lmsg);
  167.     const char *tp = msg + lmsg - (sizeof(LUA_QL("<eof>")) - 1);
  168.     if (strstr(msg, LUA_QL("<eof>")) == tp) {
  169.       lua_pop(L, 1);
  170.       return 1;
  171.     }
  172.   }
  173.   return 0;  /* else... */
  174. }
  175.  
  176.  
  177. static int pushline (lua_State *L, int firstline) {
  178.   char buffer[LUA_MAXINPUT];
  179.   char *b = buffer;
  180.   size_t l;
  181.   const char *prmt = get_prompt(L, firstline);
  182.   if (lua_readline(L, b, prmt) == 0)
  183.     return 0;  /* no input */
  184.   l = strlen(b);
  185.   if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
  186.     b[l-1] = '\0';  /* remove it */
  187.   if (firstline && b[0] == '=')  /* first line starts with `=' ? */
  188.     lua_pushfstring(L, "return %s", b+1);  /* change it to `return' */
  189.   else
  190.     lua_pushstring(L, b);
  191.   lua_freeline(L, b);
  192.   return 1;
  193. }
  194.  
  195.  
  196. static int loadline (lua_State *L) {
  197.   int status;
  198.   lua_settop(L, 0);
  199.   if (!pushline(L, 1))
  200.     return -1;  /* no input */
  201.   for (;;) {  /* repeat until gets a complete line */
  202.     status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
  203.     if (!incomplete(L, status)) break;  /* cannot try to add lines? */
  204.     if (!pushline(L, 0))  /* no more input? */
  205.       return -1;
  206.     lua_pushliteral(L, "\n");  /* add a new line... */
  207.     lua_insert(L, -2);  /* ...between the two lines */
  208.     lua_concat(L, 3);  /* join them */
  209.   }
  210.   lua_saveline(L, 1);
  211.   lua_remove(L, 1);  /* remove line */
  212.   return status;
  213. }
  214.  
  215.  
  216. static void dotty (lua_State *L) {
  217.   int status;
  218.   const char *oldprogname = progname;
  219.   progname = NULL;
  220.   while ((status = loadline(L)) != -1) {
  221.     if (status == 0) status = docall(L, 0, 0);
  222.     report(L, status);
  223.     if (status == 0 && lua_gettop(L) > 0) {  /* any result to print? */
  224.       lua_getglobal(L, "print");
  225.       lua_insert(L, 1);
  226.       if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
  227.         l_message(progname, lua_pushfstring(L,
  228.                                "error calling " LUA_QL("print") " (%s)",
  229.                                lua_tostring(L, -1)));
  230.     }
  231.   }
  232.   lua_settop(L, 0);  /* clear stack */
  233.   fputs("\n", stdout);
  234.   fflush(stdout);
  235.   progname = oldprogname;
  236. }
  237.  
  238.  
  239. static int handle_script (lua_State *L, char **argv, int n) {
  240.   int status;
  241.   const char *fname;
  242.   int narg = getargs(L, argv, n);  /* collect arguments */
  243.   lua_setglobal(L, "arg");
  244.   fname = argv[n];
  245.   if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0)
  246.     fname = NULL;  /* stdin */
  247.   status = luaL_loadfile(L, fname);
  248.   lua_insert(L, -(narg+1));
  249.   if (status == 0)
  250.     status = docall(L, narg, 0);
  251.   else
  252.     lua_pop(L, narg);      
  253.   return report(L, status);
  254. }
  255.  
  256.  
  257. /* check that argument has no extra characters at the end */
  258. #define notail(x)       {if ((x)[2] != '\0') return -1;}
  259.  
  260.  
  261. static int collectargs (char **argv, int *pi, int *pv, int *pe) {
  262.   int i;
  263.   for (i = 1; argv[i] != NULL; i++) {
  264.     if (argv[i][0] != '-')  /* not an option? */
  265.         return i;
  266.     switch (argv[i][1]) {  /* option */
  267.       case '-':
  268.         notail(argv[i]);
  269.         return (argv[i+1] != NULL ? i+1 : 0);
  270.       case '\0':
  271.         return i;
  272.       case 'i':
  273.         notail(argv[i]);
  274.         *pi = 1;  /* go through */
  275.       case 'v':
  276.         notail(argv[i]);
  277.         *pv = 1;
  278.         break;
  279.       case 'e':
  280.         *pe = 1;  /* go through */
  281.       case 'l':
  282.         if (argv[i][2] == '\0') {
  283.           i++;
  284.           if (argv[i] == NULL) return -1;
  285.         }
  286.         break;
  287.       default: return -1;  /* invalid option */
  288.     }
  289.   }
  290.   return 0;
  291. }
  292.  
  293.  
  294. static int runargs (lua_State *L, char **argv, int n) {
  295.   int i;
  296.   for (i = 1; i < n; i++) {
  297.     if (argv[i] == NULL) continue;
  298.     lua_assert(argv[i][0] == '-');
  299.     switch (argv[i][1]) {  /* option */
  300.       case 'e': {
  301.         const char *chunk = argv[i] + 2;
  302.         if (*chunk == '\0') chunk = argv[++i];
  303.         lua_assert(chunk != NULL);
  304.         if (dostring(L, chunk, "=(command line)") != 0)
  305.           return 1;
  306.         break;
  307.       }
  308.       case 'l': {
  309.         const char *filename = argv[i] + 2;
  310.         if (*filename == '\0') filename = argv[++i];
  311.         lua_assert(filename != NULL);
  312.         if (dolibrary(L, filename))
  313.           return 1;  /* stop if file fails */
  314.         break;
  315.       }
  316.       default: break;
  317.     }
  318.   }
  319.   return 0;
  320. }
  321.  
  322.  
  323. static int handle_luainit (lua_State *L) {
  324.   const char *init = getenv(LUA_INIT);
  325.   if (init == NULL) return 0;  /* status OK */
  326.   else if (init[0] == '@')
  327.     return dofile(L, init+1);
  328.   else
  329.     return dostring(L, init, "=" LUA_INIT);
  330. }
  331.  
  332.  
  333. struct Smain {
  334.   int argc;
  335.   char **argv;
  336.   int status;
  337. };
  338.  
  339.  
  340. static int pmain (lua_State *L) {
  341.   struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
  342.   char **argv = s->argv;
  343.   int script;
  344.   int has_i = 0, has_v = 0, has_e = 0;
  345.   globalL = L;
  346.   if (argv[0] && argv[0][0]) progname = argv[0];
  347.   lua_gc(L, LUA_GCSTOP, 0);  /* stop collector during initialization */
  348.   luaL_openlibs(L);  /* open libraries */
  349.   lua_gc(L, LUA_GCRESTART, 0);
  350.   s->status = handle_luainit(L);
  351.   if (s->status != 0) return 0;
  352.   script = collectargs(argv, &has_i, &has_v, &has_e);
  353.   if (script < 0) {  /* invalid args? */
  354.     print_usage();
  355.     s->status = 1;
  356.     return 0;
  357.   }
  358.   if (has_v) print_version();
  359.   s->status = runargs(L, argv, (script > 0) ? script : s->argc);
  360.   if (s->status != 0) return 0;
  361.   if (script)
  362.     s->status = handle_script(L, argv, script);
  363.   if (s->status != 0) return 0;
  364.   if (has_i)
  365.     dotty(L);
  366.   else if (script == 0 && !has_e && !has_v) {
  367.     if (lua_stdin_is_tty()) {
  368.       print_version();
  369.       dotty(L);
  370.     }
  371.     else dofile(L, NULL);  /* executes stdin as a file */
  372.   }
  373.   return 0;
  374. }
  375.  
  376.  
  377. int main (int argc, char **argv) {
  378.   int status;
  379.   struct Smain s;
  380.   lua_State *L = lua_open();  /* create state */
  381.   if (L == NULL) {
  382.     l_message(argv[0], "cannot create state: not enough memory");
  383.     return EXIT_FAILURE;
  384.   }
  385.   s.argc = argc;
  386.   s.argv = argv;
  387.   status = lua_cpcall(L, &pmain, &s);
  388.   report(L, status);
  389.   lua_close(L);
  390.   return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
  391. }
  392.  
  393.