?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  1. /*
  2. ** $Id: lauxlib.c $
  3. ** Auxiliary functions for building Lua libraries
  4. ** See Copyright Notice in lua.h
  5. */
  6.  
  7. #define lauxlib_c
  8. #define LUA_LIB
  9.  
  10. #include "lprefix.h"
  11.  
  12.  
  13. #include <errno.h>
  14. #include <stdarg.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19.  
  20. /*
  21. ** This file uses only the official API of Lua.
  22. ** Any function declared here could be written as an application function.
  23. */
  24.  
  25. #include "lua.h"
  26.  
  27. #include "lauxlib.h"
  28.  
  29.  
  30. #if !defined(MAX_SIZET)
  31. /* maximum value for size_t */
  32. #define MAX_SIZET       ((size_t)(~(size_t)0))
  33. #endif
  34.  
  35.  
  36. /*
  37. ** {======================================================
  38. ** Traceback
  39. ** =======================================================
  40. */
  41.  
  42.  
  43. #define LEVELS1 10      /* size of the first part of the stack */
  44. #define LEVELS2 11      /* size of the second part of the stack */
  45.  
  46.  
  47.  
  48. /*
  49. ** Search for 'objidx' in table at index -1. ('objidx' must be an
  50. ** absolute index.) Return 1 + string at top if it found a good name.
  51. */
  52. static int findfield (lua_State *L, int objidx, int level) {
  53.   if (level == 0 || !lua_istable(L, -1))
  54.     return 0;  /* not found */
  55.   lua_pushnil(L);  /* start 'next' loop */
  56.   while (lua_next(L, -2)) {  /* for each pair in table */
  57.     if (lua_type(L, -2) == LUA_TSTRING) {  /* ignore non-string keys */
  58.       if (lua_rawequal(L, objidx, -1)) {  /* found object? */
  59.         lua_pop(L, 1);  /* remove value (but keep name) */
  60.         return 1;
  61.       }
  62.       else if (findfield(L, objidx, level - 1)) {  /* try recursively */
  63.         /* stack: lib_name, lib_table, field_name (top) */
  64.         lua_pushliteral(L, ".");  /* place '.' between the two names */
  65.         lua_replace(L, -3);  /* (in the slot occupied by table) */
  66.         lua_concat(L, 3);  /* lib_name.field_name */
  67.         return 1;
  68.       }
  69.     }
  70.     lua_pop(L, 1);  /* remove value */
  71.   }
  72.   return 0;  /* not found */
  73. }
  74.  
  75.  
  76. /*
  77. ** Search for a name for a function in all loaded modules
  78. */
  79. static int pushglobalfuncname (lua_State *L, lua_Debug *ar) {
  80.   int top = lua_gettop(L);
  81.   lua_getinfo(L, "f", ar);  /* push function */
  82.   lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
  83.   if (findfield(L, top + 1, 2)) {
  84.     const char *name = lua_tostring(L, -1);
  85.     if (strncmp(name, LUA_GNAME ".", 3) == 0) {  /* name start with '_G.'? */
  86.       lua_pushstring(L, name + 3);  /* push name without prefix */
  87.       lua_remove(L, -2);  /* remove original name */
  88.     }
  89.     lua_copy(L, -1, top + 1);  /* copy name to proper place */
  90.     lua_settop(L, top + 1);  /* remove table "loaded" and name copy */
  91.     return 1;
  92.   }
  93.   else {
  94.     lua_settop(L, top);  /* remove function and global table */
  95.     return 0;
  96.   }
  97. }
  98.  
  99.  
  100. static void pushfuncname (lua_State *L, lua_Debug *ar) {
  101.   if (pushglobalfuncname(L, ar)) {  /* try first a global name */
  102.     lua_pushfstring(L, "function '%s'", lua_tostring(L, -1));
  103.     lua_remove(L, -2);  /* remove name */
  104.   }
  105.   else if (*ar->namewhat != '\0')  /* is there a name from code? */
  106.     lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name);  /* use it */
  107.   else if (*ar->what == 'm')  /* main? */
  108.       lua_pushliteral(L, "main chunk");
  109.   else if (*ar->what != 'C')  /* for Lua functions, use <file:line> */
  110.     lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
  111.   else  /* nothing left... */
  112.     lua_pushliteral(L, "?");
  113. }
  114.  
  115.  
  116. static int lastlevel (lua_State *L) {
  117.   lua_Debug ar;
  118.   int li = 1, le = 1;
  119.   /* find an upper bound */
  120.   while (lua_getstack(L, le, &ar)) { li = le; le *= 2; }
  121.   /* do a binary search */
  122.   while (li < le) {
  123.     int m = (li + le)/2;
  124.     if (lua_getstack(L, m, &ar)) li = m + 1;
  125.     else le = m;
  126.   }
  127.   return le - 1;
  128. }
  129.  
  130.  
  131. LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1,
  132.                                 const char *msg, int level) {
  133.   luaL_Buffer b;
  134.   lua_Debug ar;
  135.   int last = lastlevel(L1);
  136.   int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1;
  137.   luaL_buffinit(L, &b);
  138.   if (msg) {
  139.     luaL_addstring(&b, msg);
  140.     luaL_addchar(&b, '\n');
  141.   }
  142.   luaL_addstring(&b, "stack traceback:");
  143.   while (lua_getstack(L1, level++, &ar)) {
  144.     if (limit2show-- == 0) {  /* too many levels? */
  145.       int n = last - level - LEVELS2 + 1;  /* number of levels to skip */
  146.       lua_pushfstring(L, "\n\t...\t(skipping %d levels)", n);
  147.       luaL_addvalue(&b);  /* add warning about skip */
  148.       level += n;  /* and skip to last levels */
  149.     }
  150.     else {
  151.       lua_getinfo(L1, "Slnt", &ar);
  152.       if (ar.currentline <= 0)
  153.         lua_pushfstring(L, "\n\t%s: in ", ar.short_src);
  154.       else
  155.         lua_pushfstring(L, "\n\t%s:%d: in ", ar.short_src, ar.currentline);
  156.       luaL_addvalue(&b);
  157.       pushfuncname(L, &ar);
  158.       luaL_addvalue(&b);
  159.       if (ar.istailcall)
  160.         luaL_addstring(&b, "\n\t(...tail calls...)");
  161.     }
  162.   }
  163.   luaL_pushresult(&b);
  164. }
  165.  
  166. /* }====================================================== */
  167.  
  168.  
  169. /*
  170. ** {======================================================
  171. ** Error-report functions
  172. ** =======================================================
  173. */
  174.  
  175. LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) {
  176.   lua_Debug ar;
  177.   if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
  178.     return luaL_error(L, "bad argument #%d (%s)", arg, extramsg);
  179.   lua_getinfo(L, "n", &ar);
  180.   if (strcmp(ar.namewhat, "method") == 0) {
  181.     arg--;  /* do not count 'self' */
  182.     if (arg == 0)  /* error is in the self argument itself? */
  183.       return luaL_error(L, "calling '%s' on bad self (%s)",
  184.                            ar.name, extramsg);
  185.   }
  186.   if (ar.name == NULL)
  187.     ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?";
  188.   return luaL_error(L, "bad argument #%d to '%s' (%s)",
  189.                         arg, ar.name, extramsg);
  190. }
  191.  
  192.  
  193. LUALIB_API int luaL_typeerror (lua_State *L, int arg, const char *tname) {
  194.   const char *msg;
  195.   const char *typearg;  /* name for the type of the actual argument */
  196.   if (luaL_getmetafield(L, arg, "__name") == LUA_TSTRING)
  197.     typearg = lua_tostring(L, -1);  /* use the given type name */
  198.   else if (lua_type(L, arg) == LUA_TLIGHTUSERDATA)
  199.     typearg = "light userdata";  /* special name for messages */
  200.   else
  201.     typearg = luaL_typename(L, arg);  /* standard name */
  202.   msg = lua_pushfstring(L, "%s expected, got %s", tname, typearg);
  203.   return luaL_argerror(L, arg, msg);
  204. }
  205.  
  206.  
  207. static void tag_error (lua_State *L, int arg, int tag) {
  208.   luaL_typeerror(L, arg, lua_typename(L, tag));
  209. }
  210.  
  211.  
  212. /*
  213. ** The use of 'lua_pushfstring' ensures this function does not
  214. ** need reserved stack space when called.
  215. */
  216. LUALIB_API void luaL_where (lua_State *L, int level) {
  217.   lua_Debug ar;
  218.   if (lua_getstack(L, level, &ar)) {  /* check function at level */
  219.     lua_getinfo(L, "Sl", &ar);  /* get info about it */
  220.     if (ar.currentline > 0) {  /* is there info? */
  221.       lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);
  222.       return;
  223.     }
  224.   }
  225.   lua_pushfstring(L, "");  /* else, no information available... */
  226. }
  227.  
  228.  
  229. /*
  230. ** Again, the use of 'lua_pushvfstring' ensures this function does
  231. ** not need reserved stack space when called. (At worst, it generates
  232. ** an error with "stack overflow" instead of the given message.)
  233. */
  234. LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
  235.   va_list argp;
  236.   va_start(argp, fmt);
  237.   luaL_where(L, 1);
  238.   lua_pushvfstring(L, fmt, argp);
  239.   va_end(argp);
  240.   lua_concat(L, 2);
  241.   return lua_error(L);
  242. }
  243.  
  244.  
  245. LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) {
  246.   int en = errno;  /* calls to Lua API may change this value */
  247.   if (stat) {
  248.     lua_pushboolean(L, 1);
  249.     return 1;
  250.   }
  251.   else {
  252.     luaL_pushfail(L);
  253.     if (fname)
  254.       lua_pushfstring(L, "%s: %s", fname, strerror(en));
  255.     else
  256.       lua_pushstring(L, strerror(en));
  257.     lua_pushinteger(L, en);
  258.     return 3;
  259.   }
  260. }
  261.  
  262.  
  263. #if !defined(l_inspectstat)     /* { */
  264.  
  265. #if defined(LUA_USE_POSIX)
  266.  
  267. #include <sys/wait.h>
  268.  
  269. /*
  270. ** use appropriate macros to interpret 'pclose' return status
  271. */
  272. #define l_inspectstat(stat,what)  \
  273.    if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \
  274.    else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; }
  275.  
  276. #else
  277.  
  278. #define l_inspectstat(stat,what)  /* no op */
  279.  
  280. #endif
  281.  
  282. #endif                          /* } */
  283.  
  284.  
  285. LUALIB_API int luaL_execresult (lua_State *L, int stat) {
  286.   if (stat != 0 && errno != 0)  /* error with an 'errno'? */
  287.     return luaL_fileresult(L, 0, NULL);
  288.   else {
  289.     const char *what = "exit";  /* type of termination */
  290.     l_inspectstat(stat, what);  /* interpret result */
  291.     if (*what == 'e' && stat == 0)  /* successful termination? */
  292.       lua_pushboolean(L, 1);
  293.     else
  294.       luaL_pushfail(L);
  295.     lua_pushstring(L, what);
  296.     lua_pushinteger(L, stat);
  297.     return 3;  /* return true/fail,what,code */
  298.   }
  299. }
  300.  
  301. /* }====================================================== */
  302.  
  303.  
  304.  
  305. /*
  306. ** {======================================================
  307. ** Userdata's metatable manipulation
  308. ** =======================================================
  309. */
  310.  
  311. LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
  312.   if (luaL_getmetatable(L, tname) != LUA_TNIL)  /* name already in use? */
  313.     return 0;  /* leave previous value on top, but return 0 */
  314.   lua_pop(L, 1);
  315.   lua_createtable(L, 0, 2);  /* create metatable */
  316.   lua_pushstring(L, tname);
  317.   lua_setfield(L, -2, "__name");  /* metatable.__name = tname */
  318.   lua_pushvalue(L, -1);
  319.   lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
  320.   return 1;
  321. }
  322.  
  323.  
  324. LUALIB_API void luaL_setmetatable (lua_State *L, const char *tname) {
  325.   luaL_getmetatable(L, tname);
  326.   lua_setmetatable(L, -2);
  327. }
  328.  
  329.  
  330. LUALIB_API void *luaL_testudata (lua_State *L, int ud, const char *tname) {
  331.   void *p = lua_touserdata(L, ud);
  332.   if (p != NULL) {  /* value is a userdata? */
  333.     if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */
  334.       luaL_getmetatable(L, tname);  /* get correct metatable */
  335.       if (!lua_rawequal(L, -1, -2))  /* not the same? */
  336.         p = NULL;  /* value is a userdata with wrong metatable */
  337.       lua_pop(L, 2);  /* remove both metatables */
  338.       return p;
  339.     }
  340.   }
  341.   return NULL;  /* value is not a userdata with a metatable */
  342. }
  343.  
  344.  
  345. LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
  346.   void *p = luaL_testudata(L, ud, tname);
  347.   luaL_argexpected(L, p != NULL, ud, tname);
  348.   return p;
  349. }
  350.  
  351. /* }====================================================== */
  352.  
  353.  
  354. /*
  355. ** {======================================================
  356. ** Argument check functions
  357. ** =======================================================
  358. */
  359.  
  360. LUALIB_API int luaL_checkoption (lua_State *L, int arg, const char *def,
  361.                                  const char *const lst[]) {
  362.   const char *name = (def) ? luaL_optstring(L, arg, def) :
  363.                              luaL_checkstring(L, arg);
  364.   int i;
  365.   for (i=0; lst[i]; i++)
  366.     if (strcmp(lst[i], name) == 0)
  367.       return i;
  368.   return luaL_argerror(L, arg,
  369.                        lua_pushfstring(L, "invalid option '%s'", name));
  370. }
  371.  
  372.  
  373. /*
  374. ** Ensures the stack has at least 'space' extra slots, raising an error
  375. ** if it cannot fulfill the request. (The error handling needs a few
  376. ** extra slots to format the error message. In case of an error without
  377. ** this extra space, Lua will generate the same 'stack overflow' error,
  378. ** but without 'msg'.)
  379. */
  380. LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) {
  381.   if (l_unlikely(!lua_checkstack(L, space))) {
  382.     if (msg)
  383.       luaL_error(L, "stack overflow (%s)", msg);
  384.     else
  385.       luaL_error(L, "stack overflow");
  386.   }
  387. }
  388.  
  389.  
  390. LUALIB_API void luaL_checktype (lua_State *L, int arg, int t) {
  391.   if (l_unlikely(lua_type(L, arg) != t))
  392.     tag_error(L, arg, t);
  393. }
  394.  
  395.  
  396. LUALIB_API void luaL_checkany (lua_State *L, int arg) {
  397.   if (l_unlikely(lua_type(L, arg) == LUA_TNONE))
  398.     luaL_argerror(L, arg, "value expected");
  399. }
  400.  
  401.  
  402. LUALIB_API const char *luaL_checklstring (lua_State *L, int arg, size_t *len) {
  403.   const char *s = lua_tolstring(L, arg, len);
  404.   if (l_unlikely(!s)) tag_error(L, arg, LUA_TSTRING);
  405.   return s;
  406. }
  407.  
  408.  
  409. LUALIB_API const char *luaL_optlstring (lua_State *L, int arg,
  410.                                         const char *def, size_t *len) {
  411.   if (lua_isnoneornil(L, arg)) {
  412.     if (len)
  413.       *len = (def ? strlen(def) : 0);
  414.     return def;
  415.   }
  416.   else return luaL_checklstring(L, arg, len);
  417. }
  418.  
  419.  
  420. LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) {
  421.   int isnum;
  422.   lua_Number d = lua_tonumberx(L, arg, &isnum);
  423.   if (l_unlikely(!isnum))
  424.     tag_error(L, arg, LUA_TNUMBER);
  425.   return d;
  426. }
  427.  
  428.  
  429. LUALIB_API lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number def) {
  430.   return luaL_opt(L, luaL_checknumber, arg, def);
  431. }
  432.  
  433.  
  434. static void interror (lua_State *L, int arg) {
  435.   if (lua_isnumber(L, arg))
  436.     luaL_argerror(L, arg, "number has no integer representation");
  437.   else
  438.     tag_error(L, arg, LUA_TNUMBER);
  439. }
  440.  
  441.  
  442. LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) {
  443.   int isnum;
  444.   lua_Integer d = lua_tointegerx(L, arg, &isnum);
  445.   if (l_unlikely(!isnum)) {
  446.     interror(L, arg);
  447.   }
  448.   return d;
  449. }
  450.  
  451.  
  452. LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg,
  453.                                                       lua_Integer def) {
  454.   return luaL_opt(L, luaL_checkinteger, arg, def);
  455. }
  456.  
  457. /* }====================================================== */
  458.  
  459.  
  460. /*
  461. ** {======================================================
  462. ** Generic Buffer manipulation
  463. ** =======================================================
  464. */
  465.  
  466. /* userdata to box arbitrary data */
  467. typedef struct UBox {
  468.   void *box;
  469.   size_t bsize;
  470. } UBox;
  471.  
  472.  
  473. static void *resizebox (lua_State *L, int idx, size_t newsize) {
  474.   void *ud;
  475.   lua_Alloc allocf = lua_getallocf(L, &ud);
  476.   UBox *box = (UBox *)lua_touserdata(L, idx);
  477.   void *temp = allocf(ud, box->box, box->bsize, newsize);
  478.   if (l_unlikely(temp == NULL && newsize > 0)) {  /* allocation error? */
  479.     lua_pushliteral(L, "not enough memory");
  480.     lua_error(L);  /* raise a memory error */
  481.   }
  482.   box->box = temp;
  483.   box->bsize = newsize;
  484.   return temp;
  485. }
  486.  
  487.  
  488. static int boxgc (lua_State *L) {
  489.   resizebox(L, 1, 0);
  490.   return 0;
  491. }
  492.  
  493.  
  494. static const luaL_Reg boxmt[] = {  /* box metamethods */
  495.   {"__gc", boxgc},
  496.   {"__close", boxgc},
  497.   {NULL, NULL}
  498. };
  499.  
  500.  
  501. static void newbox (lua_State *L) {
  502.   UBox *box = (UBox *)lua_newuserdatauv(L, sizeof(UBox), 0);
  503.   box->box = NULL;
  504.   box->bsize = 0;
  505.   if (luaL_newmetatable(L, "_UBOX*"))  /* creating metatable? */
  506.     luaL_setfuncs(L, boxmt, 0);  /* set its metamethods */
  507.   lua_setmetatable(L, -2);
  508. }
  509.  
  510.  
  511. /*
  512. ** check whether buffer is using a userdata on the stack as a temporary
  513. ** buffer
  514. */
  515. #define buffonstack(B)  ((B)->b != (B)->init.b)
  516.  
  517.  
  518. /*
  519. ** Whenever buffer is accessed, slot 'idx' must either be a box (which
  520. ** cannot be NULL) or it is a placeholder for the buffer.
  521. */
  522. #define checkbufferlevel(B,idx)  \
  523.   lua_assert(buffonstack(B) ? lua_touserdata(B->L, idx) != NULL  \
  524.                             : lua_touserdata(B->L, idx) == (void*)B)
  525.  
  526.  
  527. /*
  528. ** Compute new size for buffer 'B', enough to accommodate extra 'sz'
  529. ** bytes.
  530. */
  531. static size_t newbuffsize (luaL_Buffer *B, size_t sz) {
  532.   size_t newsize = B->size * 2;  /* double buffer size */
  533.   if (l_unlikely(MAX_SIZET - sz < B->n))  /* overflow in (B->n + sz)? */
  534.     return luaL_error(B->L, "buffer too large");
  535.   if (newsize < B->n + sz)  /* double is not big enough? */
  536.     newsize = B->n + sz;
  537.   return newsize;
  538. }
  539.  
  540.  
  541. /*
  542. ** Returns a pointer to a free area with at least 'sz' bytes in buffer
  543. ** 'B'. 'boxidx' is the relative position in the stack where is the
  544. ** buffer's box or its placeholder.
  545. */
  546. static char *prepbuffsize (luaL_Buffer *B, size_t sz, int boxidx) {
  547.   checkbufferlevel(B, boxidx);
  548.   if (B->size - B->n >= sz)  /* enough space? */
  549.     return B->b + B->n;
  550.   else {
  551.     lua_State *L = B->L;
  552.     char *newbuff;
  553.     size_t newsize = newbuffsize(B, sz);
  554.     /* create larger buffer */
  555.     if (buffonstack(B))  /* buffer already has a box? */
  556.       newbuff = (char *)resizebox(L, boxidx, newsize);  /* resize it */
  557.     else {  /* no box yet */
  558.       lua_remove(L, boxidx);  /* remove placeholder */
  559.       newbox(L);  /* create a new box */
  560.       lua_insert(L, boxidx);  /* move box to its intended position */
  561.       lua_toclose(L, boxidx);
  562.       newbuff = (char *)resizebox(L, boxidx, newsize);
  563.       memcpy(newbuff, B->b, B->n * sizeof(char));  /* copy original content */
  564.     }
  565.     B->b = newbuff;
  566.     B->size = newsize;
  567.     return newbuff + B->n;
  568.   }
  569. }
  570.  
  571. /*
  572. ** returns a pointer to a free area with at least 'sz' bytes
  573. */
  574. LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {
  575.   return prepbuffsize(B, sz, -1);
  576. }
  577.  
  578.  
  579. LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
  580.   if (l > 0) {  /* avoid 'memcpy' when 's' can be NULL */
  581.     char *b = prepbuffsize(B, l, -1);
  582.     memcpy(b, s, l * sizeof(char));
  583.     luaL_addsize(B, l);
  584.   }
  585. }
  586.  
  587.  
  588. LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {
  589.   luaL_addlstring(B, s, strlen(s));
  590. }
  591.  
  592.  
  593. LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
  594.   lua_State *L = B->L;
  595.   checkbufferlevel(B, -1);
  596.   lua_pushlstring(L, B->b, B->n);
  597.   if (buffonstack(B))
  598.     lua_closeslot(L, -2);  /* close the box */
  599.   lua_remove(L, -2);  /* remove box or placeholder from the stack */
  600. }
  601.  
  602.  
  603. LUALIB_API void luaL_pushresultsize (luaL_Buffer *B, size_t sz) {
  604.   luaL_addsize(B, sz);
  605.   luaL_pushresult(B);
  606. }
  607.  
  608.  
  609. /*
  610. ** 'luaL_addvalue' is the only function in the Buffer system where the
  611. ** box (if existent) is not on the top of the stack. So, instead of
  612. ** calling 'luaL_addlstring', it replicates the code using -2 as the
  613. ** last argument to 'prepbuffsize', signaling that the box is (or will
  614. ** be) bellow the string being added to the buffer. (Box creation can
  615. ** trigger an emergency GC, so we should not remove the string from the
  616. ** stack before we have the space guaranteed.)
  617. */
  618. LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
  619.   lua_State *L = B->L;
  620.   size_t len;
  621.   const char *s = lua_tolstring(L, -1, &len);
  622.   char *b = prepbuffsize(B, len, -2);
  623.   memcpy(b, s, len * sizeof(char));
  624.   luaL_addsize(B, len);
  625.   lua_pop(L, 1);  /* pop string */
  626. }
  627.  
  628.  
  629. LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
  630.   B->L = L;
  631.   B->b = B->init.b;
  632.   B->n = 0;
  633.   B->size = LUAL_BUFFERSIZE;
  634.   lua_pushlightuserdata(L, (void*)B);  /* push placeholder */
  635. }
  636.  
  637.  
  638. LUALIB_API char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz) {
  639.   luaL_buffinit(L, B);
  640.   return prepbuffsize(B, sz, -1);
  641. }
  642.  
  643. /* }====================================================== */
  644.  
  645.  
  646. /*
  647. ** {======================================================
  648. ** Reference system
  649. ** =======================================================
  650. */
  651.  
  652. /* index of free-list header (after the predefined values) */
  653. #define freelist        (LUA_RIDX_LAST + 1)
  654.  
  655. /*
  656. ** The previously freed references form a linked list:
  657. ** t[freelist] is the index of a first free index, or zero if list is
  658. ** empty; t[t[freelist]] is the index of the second element; etc.
  659. */
  660. LUALIB_API int luaL_ref (lua_State *L, int t) {
  661.   int ref;
  662.   if (lua_isnil(L, -1)) {
  663.     lua_pop(L, 1);  /* remove from stack */
  664.     return LUA_REFNIL;  /* 'nil' has a unique fixed reference */
  665.   }
  666.   t = lua_absindex(L, t);
  667.   if (lua_rawgeti(L, t, freelist) == LUA_TNIL) {  /* first access? */
  668.     ref = 0;  /* list is empty */
  669.     lua_pushinteger(L, 0);  /* initialize as an empty list */
  670.     lua_rawseti(L, t, freelist);  /* ref = t[freelist] = 0 */
  671.   }
  672.   else {  /* already initialized */
  673.     lua_assert(lua_isinteger(L, -1));
  674.     ref = (int)lua_tointeger(L, -1);  /* ref = t[freelist] */
  675.   }
  676.   lua_pop(L, 1);  /* remove element from stack */
  677.   if (ref != 0) {  /* any free element? */
  678.     lua_rawgeti(L, t, ref);  /* remove it from list */
  679.     lua_rawseti(L, t, freelist);  /* (t[freelist] = t[ref]) */
  680.   }
  681.   else  /* no free elements */
  682.     ref = (int)lua_rawlen(L, t) + 1;  /* get a new reference */
  683.   lua_rawseti(L, t, ref);
  684.   return ref;
  685. }
  686.  
  687.  
  688. LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
  689.   if (ref >= 0) {
  690.     t = lua_absindex(L, t);
  691.     lua_rawgeti(L, t, freelist);
  692.     lua_assert(lua_isinteger(L, -1));
  693.     lua_rawseti(L, t, ref);  /* t[ref] = t[freelist] */
  694.     lua_pushinteger(L, ref);
  695.     lua_rawseti(L, t, freelist);  /* t[freelist] = ref */
  696.   }
  697. }
  698.  
  699. /* }====================================================== */
  700.  
  701.  
  702. /*
  703. ** {======================================================
  704. ** Load functions
  705. ** =======================================================
  706. */
  707.  
  708. typedef struct LoadF {
  709.   int n;  /* number of pre-read characters */
  710.   FILE *f;  /* file being read */
  711.   char buff[BUFSIZ];  /* area for reading file */
  712. } LoadF;
  713.  
  714.  
  715. static const char *getF (lua_State *L, void *ud, size_t *size) {
  716.   LoadF *lf = (LoadF *)ud;
  717.   (void)L;  /* not used */
  718.   if (lf->n > 0) {  /* are there pre-read characters to be read? */
  719.     *size = lf->n;  /* return them (chars already in buffer) */
  720.     lf->n = 0;  /* no more pre-read characters */
  721.   }
  722.   else {  /* read a block from file */
  723.     /* 'fread' can return > 0 *and* set the EOF flag. If next call to
  724.        'getF' called 'fread', it might still wait for user input.
  725.        The next check avoids this problem. */
  726.     if (feof(lf->f)) return NULL;
  727.     *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);  /* read block */
  728.   }
  729.   return lf->buff;
  730. }
  731.  
  732.  
  733. static int errfile (lua_State *L, const char *what, int fnameindex) {
  734.   const char *serr = strerror(errno);
  735.   const char *filename = lua_tostring(L, fnameindex) + 1;
  736.   lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
  737.   lua_remove(L, fnameindex);
  738.   return LUA_ERRFILE;
  739. }
  740.  
  741.  
  742. static int skipBOM (LoadF *lf) {
  743.   const char *p = "\xEF\xBB\xBF";  /* UTF-8 BOM mark */
  744.   int c;
  745.   lf->n = 0;
  746.   do {
  747.     c = getc(lf->f);
  748.     if (c == EOF || c != *(const unsigned char *)p++) return c;
  749.     lf->buff[lf->n++] = c;  /* to be read by the parser */
  750.   } while (*p != '\0');
  751.   lf->n = 0;  /* prefix matched; discard it */
  752.   return getc(lf->f);  /* return next character */
  753. }
  754.  
  755.  
  756. /*
  757. ** reads the first character of file 'f' and skips an optional BOM mark
  758. ** in its beginning plus its first line if it starts with '#'. Returns
  759. ** true if it skipped the first line.  In any case, '*cp' has the
  760. ** first "valid" character of the file (after the optional BOM and
  761. ** a first-line comment).
  762. */
  763. static int skipcomment (LoadF *lf, int *cp) {
  764.   int c = *cp = skipBOM(lf);
  765.   if (c == '#') {  /* first line is a comment (Unix exec. file)? */
  766.     do {  /* skip first line */
  767.       c = getc(lf->f);
  768.     } while (c != EOF && c != '\n');
  769.     *cp = getc(lf->f);  /* skip end-of-line, if present */
  770.     return 1;  /* there was a comment */
  771.   }
  772.   else return 0;  /* no comment */
  773. }
  774.  
  775.  
  776. LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename,
  777.                                              const char *mode) {
  778.   LoadF lf;
  779.   int status, readstatus;
  780.   int c;
  781.   int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */
  782.   if (filename == NULL) {
  783.     lua_pushliteral(L, "=stdin");
  784.     lf.f = stdin;
  785.   }
  786.   else {
  787.     lua_pushfstring(L, "@%s", filename);
  788.     lf.f = fopen(filename, "r");
  789.     if (lf.f == NULL) return errfile(L, "open", fnameindex);
  790.   }
  791.   if (skipcomment(&lf, &c))  /* read initial portion */
  792.     lf.buff[lf.n++] = '\n';  /* add line to correct line numbers */
  793.   if (c == LUA_SIGNATURE[0] && filename) {  /* binary file? */
  794.     lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */
  795.     if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
  796.     skipcomment(&lf, &c);  /* re-read initial portion */
  797.   }
  798.   if (c != EOF)
  799.     lf.buff[lf.n++] = c;  /* 'c' is the first character of the stream */
  800.   status = lua_load(L, getF, &lf, lua_tostring(L, -1), mode);
  801.   readstatus = ferror(lf.f);
  802.   if (filename) fclose(lf.f);  /* close file (even in case of errors) */
  803.   if (readstatus) {
  804.     lua_settop(L, fnameindex);  /* ignore results from 'lua_load' */
  805.     return errfile(L, "read", fnameindex);
  806.   }
  807.   lua_remove(L, fnameindex);
  808.   return status;
  809. }
  810.  
  811.  
  812. typedef struct LoadS {
  813.   const char *s;
  814.   size_t size;
  815. } LoadS;
  816.  
  817.  
  818. static const char *getS (lua_State *L, void *ud, size_t *size) {
  819.   LoadS *ls = (LoadS *)ud;
  820.   (void)L;  /* not used */
  821.   if (ls->size == 0) return NULL;
  822.   *size = ls->size;
  823.   ls->size = 0;
  824.   return ls->s;
  825. }
  826.  
  827.  
  828. LUALIB_API int luaL_loadbufferx (lua_State *L, const char *buff, size_t size,
  829.                                  const char *name, const char *mode) {
  830.   LoadS ls;
  831.   ls.s = buff;
  832.   ls.size = size;
  833.   return lua_load(L, getS, &ls, name, mode);
  834. }
  835.  
  836.  
  837. LUALIB_API int luaL_loadstring (lua_State *L, const char *s) {
  838.   return luaL_loadbuffer(L, s, strlen(s), s);
  839. }
  840.  
  841. /* }====================================================== */
  842.  
  843.  
  844.  
  845. LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
  846.   if (!lua_getmetatable(L, obj))  /* no metatable? */
  847.     return LUA_TNIL;
  848.   else {
  849.     int tt;
  850.     lua_pushstring(L, event);
  851.     tt = lua_rawget(L, -2);
  852.     if (tt == LUA_TNIL)  /* is metafield nil? */
  853.       lua_pop(L, 2);  /* remove metatable and metafield */
  854.     else
  855.       lua_remove(L, -2);  /* remove only metatable */
  856.     return tt;  /* return metafield type */
  857.   }
  858. }
  859.  
  860.  
  861. LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
  862.   obj = lua_absindex(L, obj);
  863.   if (luaL_getmetafield(L, obj, event) == LUA_TNIL)  /* no metafield? */
  864.     return 0;
  865.   lua_pushvalue(L, obj);
  866.   lua_call(L, 1, 1);
  867.   return 1;
  868. }
  869.  
  870.  
  871. LUALIB_API lua_Integer luaL_len (lua_State *L, int idx) {
  872.   lua_Integer l;
  873.   int isnum;
  874.   lua_len(L, idx);
  875.   l = lua_tointegerx(L, -1, &isnum);
  876.   if (l_unlikely(!isnum))
  877.     luaL_error(L, "object length is not an integer");
  878.   lua_pop(L, 1);  /* remove object */
  879.   return l;
  880. }
  881.  
  882.  
  883. LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
  884.   idx = lua_absindex(L,idx);
  885.   if (luaL_callmeta(L, idx, "__tostring")) {  /* metafield? */
  886.     if (!lua_isstring(L, -1))
  887.       luaL_error(L, "'__tostring' must return a string");
  888.   }
  889.   else {
  890.     switch (lua_type(L, idx)) {
  891.       case LUA_TNUMBER: {
  892.         if (lua_isinteger(L, idx))
  893.           lua_pushfstring(L, "%I", (LUAI_UACINT)lua_tointeger(L, idx));
  894.         else
  895.           lua_pushfstring(L, "%f", (LUAI_UACNUMBER)lua_tonumber(L, idx));
  896.         break;
  897.       }
  898.       case LUA_TSTRING:
  899.         lua_pushvalue(L, idx);
  900.         break;
  901.       case LUA_TBOOLEAN:
  902.         lua_pushstring(L, (lua_toboolean(L, idx) ? "true" : "false"));
  903.         break;
  904.       case LUA_TNIL:
  905.         lua_pushliteral(L, "nil");
  906.         break;
  907.       default: {
  908.         int tt = luaL_getmetafield(L, idx, "__name");  /* try name */
  909.         const char *kind = (tt == LUA_TSTRING) ? lua_tostring(L, -1) :
  910.                                                  luaL_typename(L, idx);
  911.         lua_pushfstring(L, "%s: %p", kind, lua_topointer(L, idx));
  912.         if (tt != LUA_TNIL)
  913.           lua_remove(L, -2);  /* remove '__name' */
  914.         break;
  915.       }
  916.     }
  917.   }
  918.   return lua_tolstring(L, -1, len);
  919. }
  920.  
  921.  
  922. /*
  923. ** set functions from list 'l' into table at top - 'nup'; each
  924. ** function gets the 'nup' elements at the top as upvalues.
  925. ** Returns with only the table at the stack.
  926. */
  927. LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
  928.   luaL_checkstack(L, nup, "too many upvalues");
  929.   for (; l->name != NULL; l++) {  /* fill the table with given functions */
  930.     if (l->func == NULL)  /* place holder? */
  931.       lua_pushboolean(L, 0);
  932.     else {
  933.       int i;
  934.       for (i = 0; i < nup; i++)  /* copy upvalues to the top */
  935.         lua_pushvalue(L, -nup);
  936.       lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
  937.     }
  938.     lua_setfield(L, -(nup + 2), l->name);
  939.   }
  940.   lua_pop(L, nup);  /* remove upvalues */
  941. }
  942.  
  943.  
  944. /*
  945. ** ensure that stack[idx][fname] has a table and push that table
  946. ** into the stack
  947. */
  948. LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
  949.   if (lua_getfield(L, idx, fname) == LUA_TTABLE)
  950.     return 1;  /* table already there */
  951.   else {
  952.     lua_pop(L, 1);  /* remove previous result */
  953.     idx = lua_absindex(L, idx);
  954.     lua_newtable(L);
  955.     lua_pushvalue(L, -1);  /* copy to be left at top */
  956.     lua_setfield(L, idx, fname);  /* assign new table to field */
  957.     return 0;  /* false, because did not find table there */
  958.   }
  959. }
  960.  
  961.  
  962. /*
  963. ** Stripped-down 'require': After checking "loaded" table, calls 'openf'
  964. ** to open a module, registers the result in 'package.loaded' table and,
  965. ** if 'glb' is true, also registers the result in the global table.
  966. ** Leaves resulting module on the top.
  967. */
  968. LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
  969.                                lua_CFunction openf, int glb) {
  970.   luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
  971.   lua_getfield(L, -1, modname);  /* LOADED[modname] */
  972.   if (!lua_toboolean(L, -1)) {  /* package not already loaded? */
  973.     lua_pop(L, 1);  /* remove field */
  974.     lua_pushcfunction(L, openf);
  975.     lua_pushstring(L, modname);  /* argument to open function */
  976.     lua_call(L, 1, 1);  /* call 'openf' to open module */
  977.     lua_pushvalue(L, -1);  /* make copy of module (call result) */
  978.     lua_setfield(L, -3, modname);  /* LOADED[modname] = module */
  979.   }
  980.   lua_remove(L, -2);  /* remove LOADED table */
  981.   if (glb) {
  982.     lua_pushvalue(L, -1);  /* copy of module */
  983.     lua_setglobal(L, modname);  /* _G[modname] = module */
  984.   }
  985. }
  986.  
  987.  
  988. LUALIB_API void luaL_addgsub (luaL_Buffer *b, const char *s,
  989.                                      const char *p, const char *r) {
  990.   const char *wild;
  991.   size_t l = strlen(p);
  992.   while ((wild = strstr(s, p)) != NULL) {
  993.     luaL_addlstring(b, s, wild - s);  /* push prefix */
  994.     luaL_addstring(b, r);  /* push replacement in place of pattern */
  995.     s = wild + l;  /* continue after 'p' */
  996.   }
  997.   luaL_addstring(b, s);  /* push last suffix */
  998. }
  999.  
  1000.  
  1001. LUALIB_API const char *luaL_gsub (lua_State *L, const char *s,
  1002.                                   const char *p, const char *r) {
  1003.   luaL_Buffer b;
  1004.   luaL_buffinit(L, &b);
  1005.   luaL_addgsub(&b, s, p, r);
  1006.   luaL_pushresult(&b);
  1007.   return lua_tostring(L, -1);
  1008. }
  1009.  
  1010.  
  1011. static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
  1012.   (void)ud; (void)osize;  /* not used */
  1013.   if (nsize == 0) {
  1014.     free(ptr);
  1015.     return NULL;
  1016.   }
  1017.   else
  1018.     return realloc(ptr, nsize);
  1019. }
  1020.  
  1021.  
  1022. static int panic (lua_State *L) {
  1023.   const char *msg = lua_tostring(L, -1);
  1024.   if (msg == NULL) msg = "error object is not a string";
  1025.   lua_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n",
  1026.                         msg);
  1027.   return 0;  /* return to Lua to abort */
  1028. }
  1029.  
  1030.  
  1031. /*
  1032. ** Warning functions:
  1033. ** warnfoff: warning system is off
  1034. ** warnfon: ready to start a new message
  1035. ** warnfcont: previous message is to be continued
  1036. */
  1037. static void warnfoff (void *ud, const char *message, int tocont);
  1038. static void warnfon (void *ud, const char *message, int tocont);
  1039. static void warnfcont (void *ud, const char *message, int tocont);
  1040.  
  1041.  
  1042. /*
  1043. ** Check whether message is a control message. If so, execute the
  1044. ** control or ignore it if unknown.
  1045. */
  1046. static int checkcontrol (lua_State *L, const char *message, int tocont) {
  1047.   if (tocont || *(message++) != '@')  /* not a control message? */
  1048.     return 0;
  1049.   else {
  1050.     if (strcmp(message, "off") == 0)
  1051.       lua_setwarnf(L, warnfoff, L);  /* turn warnings off */
  1052.     else if (strcmp(message, "on") == 0)
  1053.       lua_setwarnf(L, warnfon, L);   /* turn warnings on */
  1054.     return 1;  /* it was a control message */
  1055.   }
  1056. }
  1057.  
  1058.  
  1059. static void warnfoff (void *ud, const char *message, int tocont) {
  1060.   checkcontrol((lua_State *)ud, message, tocont);
  1061. }
  1062.  
  1063.  
  1064. /*
  1065. ** Writes the message and handle 'tocont', finishing the message
  1066. ** if needed and setting the next warn function.
  1067. */
  1068. static void warnfcont (void *ud, const char *message, int tocont) {
  1069.   lua_State *L = (lua_State *)ud;
  1070.   lua_writestringerror("%s", message);  /* write message */
  1071.   if (tocont)  /* not the last part? */
  1072.     lua_setwarnf(L, warnfcont, L);  /* to be continued */
  1073.   else {  /* last part */
  1074.     lua_writestringerror("%s", "\n");  /* finish message with end-of-line */
  1075.     lua_setwarnf(L, warnfon, L);  /* next call is a new message */
  1076.   }
  1077. }
  1078.  
  1079.  
  1080. static void warnfon (void *ud, const char *message, int tocont) {
  1081.   if (checkcontrol((lua_State *)ud, message, tocont))  /* control message? */
  1082.     return;  /* nothing else to be done */
  1083.   lua_writestringerror("%s", "Lua warning: ");  /* start a new warning */
  1084.   warnfcont(ud, message, tocont);  /* finish processing */
  1085. }
  1086.  
  1087.  
  1088. LUALIB_API lua_State *luaL_newstate (void) {
  1089.   lua_State *L = lua_newstate(l_alloc, NULL);
  1090.   if (l_likely(L)) {
  1091.     lua_atpanic(L, &panic);
  1092.     lua_setwarnf(L, warnfoff, L);  /* default is warnings off */
  1093.   }
  1094.   return L;
  1095. }
  1096.  
  1097.  
  1098. LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
  1099.   lua_Number v = lua_version(L);
  1100.   if (sz != LUAL_NUMSIZES)  /* check numeric types */
  1101.     luaL_error(L, "core and library have incompatible numeric types");
  1102.   else if (v != ver)
  1103.     luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
  1104.                   (LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)v);
  1105. }
  1106.  
  1107.