root/lib/lua/lua.c

DEFINITIONS

1. lstop
2. laction
3. print_usage
4. l_message
5. report
6. traceback
7. docall
8. print_version
9. getargs
10. dofile
11. dostring
12. dolibrary
13. get_prompt
14. incomplete
15. pushline
16. loadline
17. dotty
18. handle_script
19. collectargs
20. runargs
21. handle_luainit
22. pmain
23. main

   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 */
   8 #include <signal.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  13 #define lua_c
  15 #include "lua.h"
  17 #include "lauxlib.h"
  18 #include "lualib.h"
  22 static lua_State *globalL = NULL;
  24 static const char *progname = LUA_PROGNAME;
  28 static void lstop (lua_State *L, lua_Debug *ar) {
  29   (void)ar;  /* unused arg. */
lua_sethook(L, NULL, 0, 0);
luaL_error(L, "interrupted!");
  32 }
  35 static void laction (int i) {
signal(i, SIG_DFL); /* if another SIGINT happens before lstop,
  37                               terminate process (default action) */
lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
  39 }
  42 static void print_usage (void) {
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   ,
progname);
fflush(stderr);
  55 }
  58 static void l_message (const char *pname, const char *msg) {
  59   if (pname) fprintf(stderr, "%s: ", pname);
fprintf(stderr, "%s\n", msg);
fflush(stderr);
  62 }
  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)";
l_message(progname, msg);
lua_pop(L, 1);
  71   }
  72   return status;
  73 }
  76 static int traceback (lua_State *L) {
  77   if (!lua_isstring(L, 1))  /* 'message' not a string? */
  78     return 1;  /* keep it intact */
lua_getfield(L, LUA_GLOBALSINDEX, "debug");
  80   if (!lua_istable(L, -1)) {
lua_pop(L, 1);
  82     return 1;
  83   }
lua_getfield(L, -1, "traceback");
  85   if (!lua_isfunction(L, -1)) {
lua_pop(L, 2);
  87     return 1;
  88   }
lua_pushvalue(L, 1);  /* pass error message */
lua_pushinteger(L, 2);  /* skip this function and traceback */
lua_call(L, 2, 1);  /* call debug.traceback */
  92   return 1;
  93 }
  96 static int docall (lua_State *L, int narg, int clear) {
  97   int status;
  98   int base = lua_gettop(L) - narg;  /* function index */
lua_pushcfunction(L, traceback);  /* push traceback function */
lua_insert(L, base);  /* put it under chunk and args */
signal(SIGINT, laction);
status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
signal(SIGINT, SIG_DFL);
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 }
 111 static void print_version (void) {
l_message(NULL, LUA_RELEASE "  " LUA_COPYRIGHT);
 113 }
 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 */
narg = argc - (n + 1);  /* number of arguments to the script */
luaL_checkstack(L, narg + 3, "too many arguments to script");
 123   for (i=n+1; i < argc; i++)
lua_pushstring(L, argv[i]);
lua_createtable(L, narg, n + 1);
 126   for (i=0; i < argc; i++) {
lua_pushstring(L, argv[i]);
lua_rawseti(L, -2, i - n);
 129   }
 130   return narg;
 131 }
 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 }
 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 }
 146 static int dolibrary (lua_State *L, const char *name) {
lua_getglobal(L, "require");
lua_pushstring(L, name);
 149   return report(L, docall(L, 1, 1));
 150 }
 153 static const char *get_prompt (lua_State *L, int firstline) {
 154   const char *p;
lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");
p = lua_tostring(L, -1);
 157   if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2);
lua_pop(L, 1);  /* remove global */
 159   return p;
 160 }
 163 static int incomplete (lua_State *L, int status) {
 164   if (status == LUA_ERRSYNTAX) {
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) {
lua_pop(L, 1);
 170       return 1;
 171     }
 172   }
 173   return 0;  /* else... */
 174 }
 177 static int pushline (lua_State *L, int firstline) {
 178   char buffer[LUA_MAXINPUT];
 179   char *b = buffer;
size_t l;
 181   const char *prmt = get_prompt(L, firstline);
 182   if (lua_readline(L, b, prmt) == 0)
 183     return 0;  /* no input */
l = strlen(b);
 185   if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
b[l-1] = '\0';  /* remove it */
 187   if (firstline && b[0] == '=')  /* first line starts with `=' ? */
lua_pushfstring(L, "return %s", b+1);  /* change it to `return' */
 189   else
lua_pushstring(L, b);
lua_freeline(L, b);
 192   return 1;
 193 }
 196 static int loadline (lua_State *L) {
 197   int status;
lua_settop(L, 0);
 199   if (!pushline(L, 1))
 200     return -1;  /* no input */
 201   for (;;) {  /* repeat until gets a complete line */
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;
lua_pushliteral(L, "\n");  /* add a new line... */
lua_insert(L, -2);  /* ...between the two lines */
lua_concat(L, 3);  /* join them */
 209   }
lua_saveline(L, 1);
lua_remove(L, 1);  /* remove line */
 212   return status;
 213 }
 216 static void dotty (lua_State *L) {
 217   int status;
 218   const char *oldprogname = progname;
progname = NULL;
 220   while ((status = loadline(L)) != -1) {
 221     if (status == 0) status = docall(L, 0, 0);
report(L, status);
 223     if (status == 0 && lua_gettop(L) > 0) {  /* any result to print? */
lua_getglobal(L, "print");
lua_insert(L, 1);
 226       if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
l_message(progname, lua_pushfstring(L,
 228                                "error calling " LUA_QL("print") " (%s)",
lua_tostring(L, -1)));
 230     }
 231   }
lua_settop(L, 0);  /* clear stack */
fputs("\n", stdout);
fflush(stdout);
progname = oldprogname;
 236 }
 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 */
lua_setglobal(L, "arg");
fname = argv[n];
 245   if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0) 
fname = NULL;  /* stdin */
status = luaL_loadfile(L, fname);
lua_insert(L, -(narg+1));
 249   if (status == 0)
status = docall(L, narg, 0);
 251   else
lua_pop(L, narg);      
 253   return report(L, status);
 254 }
 257 /* check that argument has no extra characters at the end */
 258 #define notail(x)       {if ((x)[2] != '\0') return -1;}
 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 '-':
notail(argv[i]);
 269         return (argv[i+1] != NULL ? i+1 : 0);
 270       case '\0':
 271         return i;
 272       case 'i':
notail(argv[i]);
 274         *pi = 1;  /* go through */
 275       case 'v':
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') {
i++;
 284           if (argv[i] == NULL) return -1;
 285         }
 286         break;
 287       default: return -1;  /* invalid option */
 288     }
 289   }
 290   return 0;
 291 }
 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;
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];
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];
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 }
 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 }
 333 struct Smain {
 334   int argc;
 335   char **argv;
 336   int status;
 337 };
 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;
globalL = L;
 346   if (argv[0] && argv[0][0]) progname = argv[0];
lua_gc(L, LUA_GCSTOP, 0);  /* stop collector during initialization */
luaL_openlibs(L);  /* open libraries */
lua_gc(L, LUA_GCRESTART, 0);
s->status = handle_luainit(L);
 351   if (s->status != 0) return 0;
script = collectargs(argv, &has_i, &has_v, &has_e);
 353   if (script < 0) {  /* invalid args? */
print_usage();
s->status = 1;
 356     return 0;
 357   }
 358   if (has_v) print_version();
s->status = runargs(L, argv, (script > 0) ? script : s->argc);
 360   if (s->status != 0) return 0;
 361   if (script)
s->status = handle_script(L, argv, script);
 363   if (s->status != 0) return 0;
 364   if (has_i)
dotty(L);
 366   else if (script == 0 && !has_e && !has_v) {
 367     if (lua_stdin_is_tty()) {
print_version();
dotty(L);
 370     }
 371     else dofile(L, NULL);  /* executes stdin as a file */
 372   }
 373   return 0;
 374 }
 377 int main (int argc, char **argv) {
 378   int status;
 379   struct Smain s;
lua_State *L = lua_open();  /* create state */
 381   if (L == NULL) {
l_message(argv[0], "cannot create state: not enough memory");
 383     return EXIT_FAILURE;
 384   }
s.argc = argc;
s.argv = argv;
status = lua_cpcall(L, &pmain, &s);
report(L, status);
lua_close(L);
 390   return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
 391 }