"Fossies" - the Fresh Open Source Software Archive

Member "memcached-1.6.15/vendor/lua/src/ldblib.c" (1 Oct 2021, 13356 Bytes) of package /linux/www/memcached-1.6.15.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 /*
    2 ** $Id: ldblib.c $
    3 ** Interface from Lua to its debug API
    4 ** See Copyright Notice in lua.h
    5 */
    6 
    7 #define ldblib_c
    8 #define LUA_LIB
    9 
   10 #include "lprefix.h"
   11 
   12 
   13 #include <stdio.h>
   14 #include <stdlib.h>
   15 #include <string.h>
   16 
   17 #include "lua.h"
   18 
   19 #include "lauxlib.h"
   20 #include "lualib.h"
   21 
   22 
   23 /*
   24 ** The hook table at registry[HOOKKEY] maps threads to their current
   25 ** hook function.
   26 */
   27 static const char *const HOOKKEY = "_HOOKKEY";
   28 
   29 
   30 /*
   31 ** If L1 != L, L1 can be in any state, and therefore there are no
   32 ** guarantees about its stack space; any push in L1 must be
   33 ** checked.
   34 */
   35 static void checkstack (lua_State *L, lua_State *L1, int n) {
   36   if (l_unlikely(L != L1 && !lua_checkstack(L1, n)))
   37     luaL_error(L, "stack overflow");
   38 }
   39 
   40 
   41 static int db_getregistry (lua_State *L) {
   42   lua_pushvalue(L, LUA_REGISTRYINDEX);
   43   return 1;
   44 }
   45 
   46 
   47 static int db_getmetatable (lua_State *L) {
   48   luaL_checkany(L, 1);
   49   if (!lua_getmetatable(L, 1)) {
   50     lua_pushnil(L);  /* no metatable */
   51   }
   52   return 1;
   53 }
   54 
   55 
   56 static int db_setmetatable (lua_State *L) {
   57   int t = lua_type(L, 2);
   58   luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table");
   59   lua_settop(L, 2);
   60   lua_setmetatable(L, 1);
   61   return 1;  /* return 1st argument */
   62 }
   63 
   64 
   65 static int db_getuservalue (lua_State *L) {
   66   int n = (int)luaL_optinteger(L, 2, 1);
   67   if (lua_type(L, 1) != LUA_TUSERDATA)
   68     luaL_pushfail(L);
   69   else if (lua_getiuservalue(L, 1, n) != LUA_TNONE) {
   70     lua_pushboolean(L, 1);
   71     return 2;
   72   }
   73   return 1;
   74 }
   75 
   76 
   77 static int db_setuservalue (lua_State *L) {
   78   int n = (int)luaL_optinteger(L, 3, 1);
   79   luaL_checktype(L, 1, LUA_TUSERDATA);
   80   luaL_checkany(L, 2);
   81   lua_settop(L, 2);
   82   if (!lua_setiuservalue(L, 1, n))
   83     luaL_pushfail(L);
   84   return 1;
   85 }
   86 
   87 
   88 /*
   89 ** Auxiliary function used by several library functions: check for
   90 ** an optional thread as function's first argument and set 'arg' with
   91 ** 1 if this argument is present (so that functions can skip it to
   92 ** access their other arguments)
   93 */
   94 static lua_State *getthread (lua_State *L, int *arg) {
   95   if (lua_isthread(L, 1)) {
   96     *arg = 1;
   97     return lua_tothread(L, 1);
   98   }
   99   else {
  100     *arg = 0;
  101     return L;  /* function will operate over current thread */
  102   }
  103 }
  104 
  105 
  106 /*
  107 ** Variations of 'lua_settable', used by 'db_getinfo' to put results
  108 ** from 'lua_getinfo' into result table. Key is always a string;
  109 ** value can be a string, an int, or a boolean.
  110 */
  111 static void settabss (lua_State *L, const char *k, const char *v) {
  112   lua_pushstring(L, v);
  113   lua_setfield(L, -2, k);
  114 }
  115 
  116 static void settabsi (lua_State *L, const char *k, int v) {
  117   lua_pushinteger(L, v);
  118   lua_setfield(L, -2, k);
  119 }
  120 
  121 static void settabsb (lua_State *L, const char *k, int v) {
  122   lua_pushboolean(L, v);
  123   lua_setfield(L, -2, k);
  124 }
  125 
  126 
  127 /*
  128 ** In function 'db_getinfo', the call to 'lua_getinfo' may push
  129 ** results on the stack; later it creates the result table to put
  130 ** these objects. Function 'treatstackoption' puts the result from
  131 ** 'lua_getinfo' on top of the result table so that it can call
  132 ** 'lua_setfield'.
  133 */
  134 static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
  135   if (L == L1)
  136     lua_rotate(L, -2, 1);  /* exchange object and table */
  137   else
  138     lua_xmove(L1, L, 1);  /* move object to the "main" stack */
  139   lua_setfield(L, -2, fname);  /* put object into table */
  140 }
  141 
  142 
  143 /*
  144 ** Calls 'lua_getinfo' and collects all results in a new table.
  145 ** L1 needs stack space for an optional input (function) plus
  146 ** two optional outputs (function and line table) from function
  147 ** 'lua_getinfo'.
  148 */
  149 static int db_getinfo (lua_State *L) {
  150   lua_Debug ar;
  151   int arg;
  152   lua_State *L1 = getthread(L, &arg);
  153   const char *options = luaL_optstring(L, arg+2, "flnSrtu");
  154   checkstack(L, L1, 3);
  155   luaL_argcheck(L, options[0] != '>', arg + 2, "invalid option '>'");
  156   if (lua_isfunction(L, arg + 1)) {  /* info about a function? */
  157     options = lua_pushfstring(L, ">%s", options);  /* add '>' to 'options' */
  158     lua_pushvalue(L, arg + 1);  /* move function to 'L1' stack */
  159     lua_xmove(L, L1, 1);
  160   }
  161   else {  /* stack level */
  162     if (!lua_getstack(L1, (int)luaL_checkinteger(L, arg + 1), &ar)) {
  163       luaL_pushfail(L);  /* level out of range */
  164       return 1;
  165     }
  166   }
  167   if (!lua_getinfo(L1, options, &ar))
  168     return luaL_argerror(L, arg+2, "invalid option");
  169   lua_newtable(L);  /* table to collect results */
  170   if (strchr(options, 'S')) {
  171     lua_pushlstring(L, ar.source, ar.srclen);
  172     lua_setfield(L, -2, "source");
  173     settabss(L, "short_src", ar.short_src);
  174     settabsi(L, "linedefined", ar.linedefined);
  175     settabsi(L, "lastlinedefined", ar.lastlinedefined);
  176     settabss(L, "what", ar.what);
  177   }
  178   if (strchr(options, 'l'))
  179     settabsi(L, "currentline", ar.currentline);
  180   if (strchr(options, 'u')) {
  181     settabsi(L, "nups", ar.nups);
  182     settabsi(L, "nparams", ar.nparams);
  183     settabsb(L, "isvararg", ar.isvararg);
  184   }
  185   if (strchr(options, 'n')) {
  186     settabss(L, "name", ar.name);
  187     settabss(L, "namewhat", ar.namewhat);
  188   }
  189   if (strchr(options, 'r')) {
  190     settabsi(L, "ftransfer", ar.ftransfer);
  191     settabsi(L, "ntransfer", ar.ntransfer);
  192   }
  193   if (strchr(options, 't'))
  194     settabsb(L, "istailcall", ar.istailcall);
  195   if (strchr(options, 'L'))
  196     treatstackoption(L, L1, "activelines");
  197   if (strchr(options, 'f'))
  198     treatstackoption(L, L1, "func");
  199   return 1;  /* return table */
  200 }
  201 
  202 
  203 static int db_getlocal (lua_State *L) {
  204   int arg;
  205   lua_State *L1 = getthread(L, &arg);
  206   int nvar = (int)luaL_checkinteger(L, arg + 2);  /* local-variable index */
  207   if (lua_isfunction(L, arg + 1)) {  /* function argument? */
  208     lua_pushvalue(L, arg + 1);  /* push function */
  209     lua_pushstring(L, lua_getlocal(L, NULL, nvar));  /* push local name */
  210     return 1;  /* return only name (there is no value) */
  211   }
  212   else {  /* stack-level argument */
  213     lua_Debug ar;
  214     const char *name;
  215     int level = (int)luaL_checkinteger(L, arg + 1);
  216     if (l_unlikely(!lua_getstack(L1, level, &ar)))  /* out of range? */
  217       return luaL_argerror(L, arg+1, "level out of range");
  218     checkstack(L, L1, 1);
  219     name = lua_getlocal(L1, &ar, nvar);
  220     if (name) {
  221       lua_xmove(L1, L, 1);  /* move local value */
  222       lua_pushstring(L, name);  /* push name */
  223       lua_rotate(L, -2, 1);  /* re-order */
  224       return 2;
  225     }
  226     else {
  227       luaL_pushfail(L);  /* no name (nor value) */
  228       return 1;
  229     }
  230   }
  231 }
  232 
  233 
  234 static int db_setlocal (lua_State *L) {
  235   int arg;
  236   const char *name;
  237   lua_State *L1 = getthread(L, &arg);
  238   lua_Debug ar;
  239   int level = (int)luaL_checkinteger(L, arg + 1);
  240   int nvar = (int)luaL_checkinteger(L, arg + 2);
  241   if (l_unlikely(!lua_getstack(L1, level, &ar)))  /* out of range? */
  242     return luaL_argerror(L, arg+1, "level out of range");
  243   luaL_checkany(L, arg+3);
  244   lua_settop(L, arg+3);
  245   checkstack(L, L1, 1);
  246   lua_xmove(L, L1, 1);
  247   name = lua_setlocal(L1, &ar, nvar);
  248   if (name == NULL)
  249     lua_pop(L1, 1);  /* pop value (if not popped by 'lua_setlocal') */
  250   lua_pushstring(L, name);
  251   return 1;
  252 }
  253 
  254 
  255 /*
  256 ** get (if 'get' is true) or set an upvalue from a closure
  257 */
  258 static int auxupvalue (lua_State *L, int get) {
  259   const char *name;
  260   int n = (int)luaL_checkinteger(L, 2);  /* upvalue index */
  261   luaL_checktype(L, 1, LUA_TFUNCTION);  /* closure */
  262   name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
  263   if (name == NULL) return 0;
  264   lua_pushstring(L, name);
  265   lua_insert(L, -(get+1));  /* no-op if get is false */
  266   return get + 1;
  267 }
  268 
  269 
  270 static int db_getupvalue (lua_State *L) {
  271   return auxupvalue(L, 1);
  272 }
  273 
  274 
  275 static int db_setupvalue (lua_State *L) {
  276   luaL_checkany(L, 3);
  277   return auxupvalue(L, 0);
  278 }
  279 
  280 
  281 /*
  282 ** Check whether a given upvalue from a given closure exists and
  283 ** returns its index
  284 */
  285 static void *checkupval (lua_State *L, int argf, int argnup, int *pnup) {
  286   void *id;
  287   int nup = (int)luaL_checkinteger(L, argnup);  /* upvalue index */
  288   luaL_checktype(L, argf, LUA_TFUNCTION);  /* closure */
  289   id = lua_upvalueid(L, argf, nup);
  290   if (pnup) {
  291     luaL_argcheck(L, id != NULL, argnup, "invalid upvalue index");
  292     *pnup = nup;
  293   }
  294   return id;
  295 }
  296 
  297 
  298 static int db_upvalueid (lua_State *L) {
  299   void *id = checkupval(L, 1, 2, NULL);
  300   if (id != NULL)
  301     lua_pushlightuserdata(L, id);
  302   else
  303     luaL_pushfail(L);
  304   return 1;
  305 }
  306 
  307 
  308 static int db_upvaluejoin (lua_State *L) {
  309   int n1, n2;
  310   checkupval(L, 1, 2, &n1);
  311   checkupval(L, 3, 4, &n2);
  312   luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected");
  313   luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected");
  314   lua_upvaluejoin(L, 1, n1, 3, n2);
  315   return 0;
  316 }
  317 
  318 
  319 /*
  320 ** Call hook function registered at hook table for the current
  321 ** thread (if there is one)
  322 */
  323 static void hookf (lua_State *L, lua_Debug *ar) {
  324   static const char *const hooknames[] =
  325     {"call", "return", "line", "count", "tail call"};
  326   lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY);
  327   lua_pushthread(L);
  328   if (lua_rawget(L, -2) == LUA_TFUNCTION) {  /* is there a hook function? */
  329     lua_pushstring(L, hooknames[(int)ar->event]);  /* push event name */
  330     if (ar->currentline >= 0)
  331       lua_pushinteger(L, ar->currentline);  /* push current line */
  332     else lua_pushnil(L);
  333     lua_assert(lua_getinfo(L, "lS", ar));
  334     lua_call(L, 2, 0);  /* call hook function */
  335   }
  336 }
  337 
  338 
  339 /*
  340 ** Convert a string mask (for 'sethook') into a bit mask
  341 */
  342 static int makemask (const char *smask, int count) {
  343   int mask = 0;
  344   if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
  345   if (strchr(smask, 'r')) mask |= LUA_MASKRET;
  346   if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
  347   if (count > 0) mask |= LUA_MASKCOUNT;
  348   return mask;
  349 }
  350 
  351 
  352 /*
  353 ** Convert a bit mask (for 'gethook') into a string mask
  354 */
  355 static char *unmakemask (int mask, char *smask) {
  356   int i = 0;
  357   if (mask & LUA_MASKCALL) smask[i++] = 'c';
  358   if (mask & LUA_MASKRET) smask[i++] = 'r';
  359   if (mask & LUA_MASKLINE) smask[i++] = 'l';
  360   smask[i] = '\0';
  361   return smask;
  362 }
  363 
  364 
  365 static int db_sethook (lua_State *L) {
  366   int arg, mask, count;
  367   lua_Hook func;
  368   lua_State *L1 = getthread(L, &arg);
  369   if (lua_isnoneornil(L, arg+1)) {  /* no hook? */
  370     lua_settop(L, arg+1);
  371     func = NULL; mask = 0; count = 0;  /* turn off hooks */
  372   }
  373   else {
  374     const char *smask = luaL_checkstring(L, arg+2);
  375     luaL_checktype(L, arg+1, LUA_TFUNCTION);
  376     count = (int)luaL_optinteger(L, arg + 3, 0);
  377     func = hookf; mask = makemask(smask, count);
  378   }
  379   if (!luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)) {
  380     /* table just created; initialize it */
  381     lua_pushliteral(L, "k");
  382     lua_setfield(L, -2, "__mode");  /** hooktable.__mode = "k" */
  383     lua_pushvalue(L, -1);
  384     lua_setmetatable(L, -2);  /* metatable(hooktable) = hooktable */
  385   }
  386   checkstack(L, L1, 1);
  387   lua_pushthread(L1); lua_xmove(L1, L, 1);  /* key (thread) */
  388   lua_pushvalue(L, arg + 1);  /* value (hook function) */
  389   lua_rawset(L, -3);  /* hooktable[L1] = new Lua hook */
  390   lua_sethook(L1, func, mask, count);
  391   return 0;
  392 }
  393 
  394 
  395 static int db_gethook (lua_State *L) {
  396   int arg;
  397   lua_State *L1 = getthread(L, &arg);
  398   char buff[5];
  399   int mask = lua_gethookmask(L1);
  400   lua_Hook hook = lua_gethook(L1);
  401   if (hook == NULL) {  /* no hook? */
  402     luaL_pushfail(L);
  403     return 1;
  404   }
  405   else if (hook != hookf)  /* external hook? */
  406     lua_pushliteral(L, "external hook");
  407   else {  /* hook table must exist */
  408     lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY);
  409     checkstack(L, L1, 1);
  410     lua_pushthread(L1); lua_xmove(L1, L, 1);
  411     lua_rawget(L, -2);   /* 1st result = hooktable[L1] */
  412     lua_remove(L, -2);  /* remove hook table */
  413   }
  414   lua_pushstring(L, unmakemask(mask, buff));  /* 2nd result = mask */
  415   lua_pushinteger(L, lua_gethookcount(L1));  /* 3rd result = count */
  416   return 3;
  417 }
  418 
  419 
  420 static int db_debug (lua_State *L) {
  421   for (;;) {
  422     char buffer[250];
  423     lua_writestringerror("%s", "lua_debug> ");
  424     if (fgets(buffer, sizeof(buffer), stdin) == NULL ||
  425         strcmp(buffer, "cont\n") == 0)
  426       return 0;
  427     if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
  428         lua_pcall(L, 0, 0, 0))
  429       lua_writestringerror("%s\n", luaL_tolstring(L, -1, NULL));
  430     lua_settop(L, 0);  /* remove eventual returns */
  431   }
  432 }
  433 
  434 
  435 static int db_traceback (lua_State *L) {
  436   int arg;
  437   lua_State *L1 = getthread(L, &arg);
  438   const char *msg = lua_tostring(L, arg + 1);
  439   if (msg == NULL && !lua_isnoneornil(L, arg + 1))  /* non-string 'msg'? */
  440     lua_pushvalue(L, arg + 1);  /* return it untouched */
  441   else {
  442     int level = (int)luaL_optinteger(L, arg + 2, (L == L1) ? 1 : 0);
  443     luaL_traceback(L, L1, msg, level);
  444   }
  445   return 1;
  446 }
  447 
  448 
  449 static int db_setcstacklimit (lua_State *L) {
  450   int limit = (int)luaL_checkinteger(L, 1);
  451   int res = lua_setcstacklimit(L, limit);
  452   lua_pushinteger(L, res);
  453   return 1;
  454 }
  455 
  456 
  457 static const luaL_Reg dblib[] = {
  458   {"debug", db_debug},
  459   {"getuservalue", db_getuservalue},
  460   {"gethook", db_gethook},
  461   {"getinfo", db_getinfo},
  462   {"getlocal", db_getlocal},
  463   {"getregistry", db_getregistry},
  464   {"getmetatable", db_getmetatable},
  465   {"getupvalue", db_getupvalue},
  466   {"upvaluejoin", db_upvaluejoin},
  467   {"upvalueid", db_upvalueid},
  468   {"setuservalue", db_setuservalue},
  469   {"sethook", db_sethook},
  470   {"setlocal", db_setlocal},
  471   {"setmetatable", db_setmetatable},
  472   {"setupvalue", db_setupvalue},
  473   {"traceback", db_traceback},
  474   {"setcstacklimit", db_setcstacklimit},
  475   {NULL, NULL}
  476 };
  477 
  478 
  479 LUAMOD_API int luaopen_debug (lua_State *L) {
  480   luaL_newlib(L, dblib);
  481   return 1;
  482 }
  483