"Fossies" - the Fresh Open Source Software Archive

Member "memcached-1.6.15/vendor/lua/src/lobject.h" (1 Oct 2021, 22392 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: lobject.h $
    3 ** Type definitions for Lua objects
    4 ** See Copyright Notice in lua.h
    5 */
    6 
    7 
    8 #ifndef lobject_h
    9 #define lobject_h
   10 
   11 
   12 #include <stdarg.h>
   13 
   14 
   15 #include "llimits.h"
   16 #include "lua.h"
   17 
   18 
   19 /*
   20 ** Extra types for collectable non-values
   21 */
   22 #define LUA_TUPVAL  LUA_NUMTYPES  /* upvalues */
   23 #define LUA_TPROTO  (LUA_NUMTYPES+1)  /* function prototypes */
   24 #define LUA_TDEADKEY    (LUA_NUMTYPES+2)  /* removed keys in tables */
   25 
   26 
   27 
   28 /*
   29 ** number of all possible types (including LUA_TNONE but excluding DEADKEY)
   30 */
   31 #define LUA_TOTALTYPES      (LUA_TPROTO + 2)
   32 
   33 
   34 /*
   35 ** tags for Tagged Values have the following use of bits:
   36 ** bits 0-3: actual tag (a LUA_T* constant)
   37 ** bits 4-5: variant bits
   38 ** bit 6: whether value is collectable
   39 */
   40 
   41 /* add variant bits to a type */
   42 #define makevariant(t,v)    ((t) | ((v) << 4))
   43 
   44 
   45 
   46 /*
   47 ** Union of all Lua values
   48 */
   49 typedef union Value {
   50   struct GCObject *gc;    /* collectable objects */
   51   void *p;         /* light userdata */
   52   lua_CFunction f; /* light C functions */
   53   lua_Integer i;   /* integer numbers */
   54   lua_Number n;    /* float numbers */
   55 } Value;
   56 
   57 
   58 /*
   59 ** Tagged Values. This is the basic representation of values in Lua:
   60 ** an actual value plus a tag with its type.
   61 */
   62 
   63 #define TValuefields    Value value_; lu_byte tt_
   64 
   65 typedef struct TValue {
   66   TValuefields;
   67 } TValue;
   68 
   69 
   70 #define val_(o)     ((o)->value_)
   71 #define valraw(o)   (&val_(o))
   72 
   73 
   74 /* raw type tag of a TValue */
   75 #define rawtt(o)    ((o)->tt_)
   76 
   77 /* tag with no variants (bits 0-3) */
   78 #define novariant(t)    ((t) & 0x0F)
   79 
   80 /* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
   81 #define withvariant(t)  ((t) & 0x3F)
   82 #define ttypetag(o) withvariant(rawtt(o))
   83 
   84 /* type of a TValue */
   85 #define ttype(o)    (novariant(rawtt(o)))
   86 
   87 
   88 /* Macros to test type */
   89 #define checktag(o,t)       (rawtt(o) == (t))
   90 #define checktype(o,t)      (ttype(o) == (t))
   91 
   92 
   93 /* Macros for internal tests */
   94 
   95 /* collectable object has the same tag as the original value */
   96 #define righttt(obj)        (ttypetag(obj) == gcvalue(obj)->tt)
   97 
   98 /*
   99 ** Any value being manipulated by the program either is non
  100 ** collectable, or the collectable object has the right tag
  101 ** and it is not dead. The option 'L == NULL' allows other
  102 ** macros using this one to be used where L is not available.
  103 */
  104 #define checkliveness(L,obj) \
  105     ((void)L, lua_longassert(!iscollectable(obj) || \
  106         (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj))))))
  107 
  108 
  109 /* Macros to set values */
  110 
  111 /* set a value's tag */
  112 #define settt_(o,t) ((o)->tt_=(t))
  113 
  114 
  115 /* main macro to copy values (from 'obj1' to 'obj2') */
  116 #define setobj(L,obj1,obj2) \
  117     { TValue *io1=(obj1); const TValue *io2=(obj2); \
  118           io1->value_ = io2->value_; settt_(io1, io2->tt_); \
  119       checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); }
  120 
  121 /*
  122 ** Different types of assignments, according to source and destination.
  123 ** (They are mostly equal now, but may be different in the future.)
  124 */
  125 
  126 /* from stack to stack */
  127 #define setobjs2s(L,o1,o2)  setobj(L,s2v(o1),s2v(o2))
  128 /* to stack (not from same stack) */
  129 #define setobj2s(L,o1,o2)   setobj(L,s2v(o1),o2)
  130 /* from table to same table */
  131 #define setobjt2t   setobj
  132 /* to new object */
  133 #define setobj2n    setobj
  134 /* to table */
  135 #define setobj2t    setobj
  136 
  137 
  138 /*
  139 ** Entries in a Lua stack. Field 'tbclist' forms a list of all
  140 ** to-be-closed variables active in this stack. Dummy entries are
  141 ** used when the distance between two tbc variables does not fit
  142 ** in an unsigned short. They are represented by delta==0, and
  143 ** their real delta is always the maximum value that fits in
  144 ** that field.
  145 */
  146 typedef union StackValue {
  147   TValue val;
  148   struct {
  149     TValuefields;
  150     unsigned short delta;
  151   } tbclist;
  152 } StackValue;
  153 
  154 
  155 /* index to stack elements */
  156 typedef StackValue *StkId;
  157 
  158 /* convert a 'StackValue' to a 'TValue' */
  159 #define s2v(o)  (&(o)->val)
  160 
  161 
  162 
  163 /*
  164 ** {==================================================================
  165 ** Nil
  166 ** ===================================================================
  167 */
  168 
  169 /* Standard nil */
  170 #define LUA_VNIL    makevariant(LUA_TNIL, 0)
  171 
  172 /* Empty slot (which might be different from a slot containing nil) */
  173 #define LUA_VEMPTY  makevariant(LUA_TNIL, 1)
  174 
  175 /* Value returned for a key not found in a table (absent key) */
  176 #define LUA_VABSTKEY    makevariant(LUA_TNIL, 2)
  177 
  178 
  179 /* macro to test for (any kind of) nil */
  180 #define ttisnil(v)      checktype((v), LUA_TNIL)
  181 
  182 
  183 /* macro to test for a standard nil */
  184 #define ttisstrictnil(o)    checktag((o), LUA_VNIL)
  185 
  186 
  187 #define setnilvalue(obj) settt_(obj, LUA_VNIL)
  188 
  189 
  190 #define isabstkey(v)        checktag((v), LUA_VABSTKEY)
  191 
  192 
  193 /*
  194 ** macro to detect non-standard nils (used only in assertions)
  195 */
  196 #define isnonstrictnil(v)   (ttisnil(v) && !ttisstrictnil(v))
  197 
  198 
  199 /*
  200 ** By default, entries with any kind of nil are considered empty.
  201 ** (In any definition, values associated with absent keys must also
  202 ** be accepted as empty.)
  203 */
  204 #define isempty(v)      ttisnil(v)
  205 
  206 
  207 /* macro defining a value corresponding to an absent key */
  208 #define ABSTKEYCONSTANT     {NULL}, LUA_VABSTKEY
  209 
  210 
  211 /* mark an entry as empty */
  212 #define setempty(v)     settt_(v, LUA_VEMPTY)
  213 
  214 
  215 
  216 /* }================================================================== */
  217 
  218 
  219 /*
  220 ** {==================================================================
  221 ** Booleans
  222 ** ===================================================================
  223 */
  224 
  225 
  226 #define LUA_VFALSE  makevariant(LUA_TBOOLEAN, 0)
  227 #define LUA_VTRUE   makevariant(LUA_TBOOLEAN, 1)
  228 
  229 #define ttisboolean(o)      checktype((o), LUA_TBOOLEAN)
  230 #define ttisfalse(o)        checktag((o), LUA_VFALSE)
  231 #define ttistrue(o)     checktag((o), LUA_VTRUE)
  232 
  233 
  234 #define l_isfalse(o)    (ttisfalse(o) || ttisnil(o))
  235 
  236 
  237 #define setbfvalue(obj)     settt_(obj, LUA_VFALSE)
  238 #define setbtvalue(obj)     settt_(obj, LUA_VTRUE)
  239 
  240 /* }================================================================== */
  241 
  242 
  243 /*
  244 ** {==================================================================
  245 ** Threads
  246 ** ===================================================================
  247 */
  248 
  249 #define LUA_VTHREAD     makevariant(LUA_TTHREAD, 0)
  250 
  251 #define ttisthread(o)       checktag((o), ctb(LUA_VTHREAD))
  252 
  253 #define thvalue(o)  check_exp(ttisthread(o), gco2th(val_(o).gc))
  254 
  255 #define setthvalue(L,obj,x) \
  256   { TValue *io = (obj); lua_State *x_ = (x); \
  257     val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \
  258     checkliveness(L,io); }
  259 
  260 #define setthvalue2s(L,o,t) setthvalue(L,s2v(o),t)
  261 
  262 /* }================================================================== */
  263 
  264 
  265 /*
  266 ** {==================================================================
  267 ** Collectable Objects
  268 ** ===================================================================
  269 */
  270 
  271 /*
  272 ** Common Header for all collectable objects (in macro form, to be
  273 ** included in other objects)
  274 */
  275 #define CommonHeader    struct GCObject *next; lu_byte tt; lu_byte marked
  276 
  277 
  278 /* Common type for all collectable objects */
  279 typedef struct GCObject {
  280   CommonHeader;
  281 } GCObject;
  282 
  283 
  284 /* Bit mark for collectable types */
  285 #define BIT_ISCOLLECTABLE   (1 << 6)
  286 
  287 #define iscollectable(o)    (rawtt(o) & BIT_ISCOLLECTABLE)
  288 
  289 /* mark a tag as collectable */
  290 #define ctb(t)          ((t) | BIT_ISCOLLECTABLE)
  291 
  292 #define gcvalue(o)  check_exp(iscollectable(o), val_(o).gc)
  293 
  294 #define gcvalueraw(v)   ((v).gc)
  295 
  296 #define setgcovalue(L,obj,x) \
  297   { TValue *io = (obj); GCObject *i_g=(x); \
  298     val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); }
  299 
  300 /* }================================================================== */
  301 
  302 
  303 /*
  304 ** {==================================================================
  305 ** Numbers
  306 ** ===================================================================
  307 */
  308 
  309 /* Variant tags for numbers */
  310 #define LUA_VNUMINT makevariant(LUA_TNUMBER, 0)  /* integer numbers */
  311 #define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1)  /* float numbers */
  312 
  313 #define ttisnumber(o)       checktype((o), LUA_TNUMBER)
  314 #define ttisfloat(o)        checktag((o), LUA_VNUMFLT)
  315 #define ttisinteger(o)      checktag((o), LUA_VNUMINT)
  316 
  317 #define nvalue(o)   check_exp(ttisnumber(o), \
  318     (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o)))
  319 #define fltvalue(o) check_exp(ttisfloat(o), val_(o).n)
  320 #define ivalue(o)   check_exp(ttisinteger(o), val_(o).i)
  321 
  322 #define fltvalueraw(v)  ((v).n)
  323 #define ivalueraw(v)    ((v).i)
  324 
  325 #define setfltvalue(obj,x) \
  326   { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); }
  327 
  328 #define chgfltvalue(obj,x) \
  329   { TValue *io=(obj); lua_assert(ttisfloat(io)); val_(io).n=(x); }
  330 
  331 #define setivalue(obj,x) \
  332   { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); }
  333 
  334 #define chgivalue(obj,x) \
  335   { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); }
  336 
  337 /* }================================================================== */
  338 
  339 
  340 /*
  341 ** {==================================================================
  342 ** Strings
  343 ** ===================================================================
  344 */
  345 
  346 /* Variant tags for strings */
  347 #define LUA_VSHRSTR makevariant(LUA_TSTRING, 0)  /* short strings */
  348 #define LUA_VLNGSTR makevariant(LUA_TSTRING, 1)  /* long strings */
  349 
  350 #define ttisstring(o)       checktype((o), LUA_TSTRING)
  351 #define ttisshrstring(o)    checktag((o), ctb(LUA_VSHRSTR))
  352 #define ttislngstring(o)    checktag((o), ctb(LUA_VLNGSTR))
  353 
  354 #define tsvalueraw(v)   (gco2ts((v).gc))
  355 
  356 #define tsvalue(o)  check_exp(ttisstring(o), gco2ts(val_(o).gc))
  357 
  358 #define setsvalue(L,obj,x) \
  359   { TValue *io = (obj); TString *x_ = (x); \
  360     val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \
  361     checkliveness(L,io); }
  362 
  363 /* set a string to the stack */
  364 #define setsvalue2s(L,o,s)  setsvalue(L,s2v(o),s)
  365 
  366 /* set a string to a new object */
  367 #define setsvalue2n setsvalue
  368 
  369 
  370 /*
  371 ** Header for a string value.
  372 */
  373 typedef struct TString {
  374   CommonHeader;
  375   lu_byte extra;  /* reserved words for short strings; "has hash" for longs */
  376   lu_byte shrlen;  /* length for short strings */
  377   unsigned int hash;
  378   union {
  379     size_t lnglen;  /* length for long strings */
  380     struct TString *hnext;  /* linked list for hash table */
  381   } u;
  382   char contents[1];
  383 } TString;
  384 
  385 
  386 
  387 /*
  388 ** Get the actual string (array of bytes) from a 'TString'.
  389 */
  390 #define getstr(ts)  ((ts)->contents)
  391 
  392 
  393 /* get the actual string (array of bytes) from a Lua value */
  394 #define svalue(o)       getstr(tsvalue(o))
  395 
  396 /* get string length from 'TString *s' */
  397 #define tsslen(s)   ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen)
  398 
  399 /* get string length from 'TValue *o' */
  400 #define vslen(o)    tsslen(tsvalue(o))
  401 
  402 /* }================================================================== */
  403 
  404 
  405 /*
  406 ** {==================================================================
  407 ** Userdata
  408 ** ===================================================================
  409 */
  410 
  411 
  412 /*
  413 ** Light userdata should be a variant of userdata, but for compatibility
  414 ** reasons they are also different types.
  415 */
  416 #define LUA_VLIGHTUSERDATA  makevariant(LUA_TLIGHTUSERDATA, 0)
  417 
  418 #define LUA_VUSERDATA       makevariant(LUA_TUSERDATA, 0)
  419 
  420 #define ttislightuserdata(o)    checktag((o), LUA_VLIGHTUSERDATA)
  421 #define ttisfulluserdata(o) checktag((o), ctb(LUA_VUSERDATA))
  422 
  423 #define pvalue(o)   check_exp(ttislightuserdata(o), val_(o).p)
  424 #define uvalue(o)   check_exp(ttisfulluserdata(o), gco2u(val_(o).gc))
  425 
  426 #define pvalueraw(v)    ((v).p)
  427 
  428 #define setpvalue(obj,x) \
  429   { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); }
  430 
  431 #define setuvalue(L,obj,x) \
  432   { TValue *io = (obj); Udata *x_ = (x); \
  433     val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \
  434     checkliveness(L,io); }
  435 
  436 
  437 /* Ensures that addresses after this type are always fully aligned. */
  438 typedef union UValue {
  439   TValue uv;
  440   LUAI_MAXALIGN;  /* ensures maximum alignment for udata bytes */
  441 } UValue;
  442 
  443 
  444 /*
  445 ** Header for userdata with user values;
  446 ** memory area follows the end of this structure.
  447 */
  448 typedef struct Udata {
  449   CommonHeader;
  450   unsigned short nuvalue;  /* number of user values */
  451   size_t len;  /* number of bytes */
  452   struct Table *metatable;
  453   GCObject *gclist;
  454   UValue uv[1];  /* user values */
  455 } Udata;
  456 
  457 
  458 /*
  459 ** Header for userdata with no user values. These userdata do not need
  460 ** to be gray during GC, and therefore do not need a 'gclist' field.
  461 ** To simplify, the code always use 'Udata' for both kinds of userdata,
  462 ** making sure it never accesses 'gclist' on userdata with no user values.
  463 ** This structure here is used only to compute the correct size for
  464 ** this representation. (The 'bindata' field in its end ensures correct
  465 ** alignment for binary data following this header.)
  466 */
  467 typedef struct Udata0 {
  468   CommonHeader;
  469   unsigned short nuvalue;  /* number of user values */
  470   size_t len;  /* number of bytes */
  471   struct Table *metatable;
  472   union {LUAI_MAXALIGN;} bindata;
  473 } Udata0;
  474 
  475 
  476 /* compute the offset of the memory area of a userdata */
  477 #define udatamemoffset(nuv) \
  478     ((nuv) == 0 ? offsetof(Udata0, bindata)  \
  479                     : offsetof(Udata, uv) + (sizeof(UValue) * (nuv)))
  480 
  481 /* get the address of the memory block inside 'Udata' */
  482 #define getudatamem(u)  (cast_charp(u) + udatamemoffset((u)->nuvalue))
  483 
  484 /* compute the size of a userdata */
  485 #define sizeudata(nuv,nb)   (udatamemoffset(nuv) + (nb))
  486 
  487 /* }================================================================== */
  488 
  489 
  490 /*
  491 ** {==================================================================
  492 ** Prototypes
  493 ** ===================================================================
  494 */
  495 
  496 #define LUA_VPROTO  makevariant(LUA_TPROTO, 0)
  497 
  498 
  499 /*
  500 ** Description of an upvalue for function prototypes
  501 */
  502 typedef struct Upvaldesc {
  503   TString *name;  /* upvalue name (for debug information) */
  504   lu_byte instack;  /* whether it is in stack (register) */
  505   lu_byte idx;  /* index of upvalue (in stack or in outer function's list) */
  506   lu_byte kind;  /* kind of corresponding variable */
  507 } Upvaldesc;
  508 
  509 
  510 /*
  511 ** Description of a local variable for function prototypes
  512 ** (used for debug information)
  513 */
  514 typedef struct LocVar {
  515   TString *varname;
  516   int startpc;  /* first point where variable is active */
  517   int endpc;    /* first point where variable is dead */
  518 } LocVar;
  519 
  520 
  521 /*
  522 ** Associates the absolute line source for a given instruction ('pc').
  523 ** The array 'lineinfo' gives, for each instruction, the difference in
  524 ** lines from the previous instruction. When that difference does not
  525 ** fit into a byte, Lua saves the absolute line for that instruction.
  526 ** (Lua also saves the absolute line periodically, to speed up the
  527 ** computation of a line number: we can use binary search in the
  528 ** absolute-line array, but we must traverse the 'lineinfo' array
  529 ** linearly to compute a line.)
  530 */
  531 typedef struct AbsLineInfo {
  532   int pc;
  533   int line;
  534 } AbsLineInfo;
  535 
  536 /*
  537 ** Function Prototypes
  538 */
  539 typedef struct Proto {
  540   CommonHeader;
  541   lu_byte numparams;  /* number of fixed (named) parameters */
  542   lu_byte is_vararg;
  543   lu_byte maxstacksize;  /* number of registers needed by this function */
  544   int sizeupvalues;  /* size of 'upvalues' */
  545   int sizek;  /* size of 'k' */
  546   int sizecode;
  547   int sizelineinfo;
  548   int sizep;  /* size of 'p' */
  549   int sizelocvars;
  550   int sizeabslineinfo;  /* size of 'abslineinfo' */
  551   int linedefined;  /* debug information  */
  552   int lastlinedefined;  /* debug information  */
  553   TValue *k;  /* constants used by the function */
  554   Instruction *code;  /* opcodes */
  555   struct Proto **p;  /* functions defined inside the function */
  556   Upvaldesc *upvalues;  /* upvalue information */
  557   ls_byte *lineinfo;  /* information about source lines (debug information) */
  558   AbsLineInfo *abslineinfo;  /* idem */
  559   LocVar *locvars;  /* information about local variables (debug information) */
  560   TString  *source;  /* used for debug information */
  561   GCObject *gclist;
  562 } Proto;
  563 
  564 /* }================================================================== */
  565 
  566 
  567 /*
  568 ** {==================================================================
  569 ** Functions
  570 ** ===================================================================
  571 */
  572 
  573 #define LUA_VUPVAL  makevariant(LUA_TUPVAL, 0)
  574 
  575 
  576 /* Variant tags for functions */
  577 #define LUA_VLCL    makevariant(LUA_TFUNCTION, 0)  /* Lua closure */
  578 #define LUA_VLCF    makevariant(LUA_TFUNCTION, 1)  /* light C function */
  579 #define LUA_VCCL    makevariant(LUA_TFUNCTION, 2)  /* C closure */
  580 
  581 #define ttisfunction(o)     checktype(o, LUA_TFUNCTION)
  582 #define ttisLclosure(o)     checktag((o), ctb(LUA_VLCL))
  583 #define ttislcf(o)      checktag((o), LUA_VLCF)
  584 #define ttisCclosure(o)     checktag((o), ctb(LUA_VCCL))
  585 #define ttisclosure(o)         (ttisLclosure(o) || ttisCclosure(o))
  586 
  587 
  588 #define isLfunction(o)  ttisLclosure(o)
  589 
  590 #define clvalue(o)  check_exp(ttisclosure(o), gco2cl(val_(o).gc))
  591 #define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc))
  592 #define fvalue(o)   check_exp(ttislcf(o), val_(o).f)
  593 #define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc))
  594 
  595 #define fvalueraw(v)    ((v).f)
  596 
  597 #define setclLvalue(L,obj,x) \
  598   { TValue *io = (obj); LClosure *x_ = (x); \
  599     val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \
  600     checkliveness(L,io); }
  601 
  602 #define setclLvalue2s(L,o,cl)   setclLvalue(L,s2v(o),cl)
  603 
  604 #define setfvalue(obj,x) \
  605   { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); }
  606 
  607 #define setclCvalue(L,obj,x) \
  608   { TValue *io = (obj); CClosure *x_ = (x); \
  609     val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VCCL)); \
  610     checkliveness(L,io); }
  611 
  612 
  613 /*
  614 ** Upvalues for Lua closures
  615 */
  616 typedef struct UpVal {
  617   CommonHeader;
  618   lu_byte tbc;  /* true if it represents a to-be-closed variable */
  619   TValue *v;  /* points to stack or to its own value */
  620   union {
  621     struct {  /* (when open) */
  622       struct UpVal *next;  /* linked list */
  623       struct UpVal **previous;
  624     } open;
  625     TValue value;  /* the value (when closed) */
  626   } u;
  627 } UpVal;
  628 
  629 
  630 
  631 #define ClosureHeader \
  632     CommonHeader; lu_byte nupvalues; GCObject *gclist
  633 
  634 typedef struct CClosure {
  635   ClosureHeader;
  636   lua_CFunction f;
  637   TValue upvalue[1];  /* list of upvalues */
  638 } CClosure;
  639 
  640 
  641 typedef struct LClosure {
  642   ClosureHeader;
  643   struct Proto *p;
  644   UpVal *upvals[1];  /* list of upvalues */
  645 } LClosure;
  646 
  647 
  648 typedef union Closure {
  649   CClosure c;
  650   LClosure l;
  651 } Closure;
  652 
  653 
  654 #define getproto(o) (clLvalue(o)->p)
  655 
  656 /* }================================================================== */
  657 
  658 
  659 /*
  660 ** {==================================================================
  661 ** Tables
  662 ** ===================================================================
  663 */
  664 
  665 #define LUA_VTABLE  makevariant(LUA_TTABLE, 0)
  666 
  667 #define ttistable(o)        checktag((o), ctb(LUA_VTABLE))
  668 
  669 #define hvalue(o)   check_exp(ttistable(o), gco2t(val_(o).gc))
  670 
  671 #define sethvalue(L,obj,x) \
  672   { TValue *io = (obj); Table *x_ = (x); \
  673     val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \
  674     checkliveness(L,io); }
  675 
  676 #define sethvalue2s(L,o,h)  sethvalue(L,s2v(o),h)
  677 
  678 
  679 /*
  680 ** Nodes for Hash tables: A pack of two TValue's (key-value pairs)
  681 ** plus a 'next' field to link colliding entries. The distribution
  682 ** of the key's fields ('key_tt' and 'key_val') not forming a proper
  683 ** 'TValue' allows for a smaller size for 'Node' both in 4-byte
  684 ** and 8-byte alignments.
  685 */
  686 typedef union Node {
  687   struct NodeKey {
  688     TValuefields;  /* fields for value */
  689     lu_byte key_tt;  /* key type */
  690     int next;  /* for chaining */
  691     Value key_val;  /* key value */
  692   } u;
  693   TValue i_val;  /* direct access to node's value as a proper 'TValue' */
  694 } Node;
  695 
  696 
  697 /* copy a value into a key */
  698 #define setnodekey(L,node,obj) \
  699     { Node *n_=(node); const TValue *io_=(obj); \
  700       n_->u.key_val = io_->value_; n_->u.key_tt = io_->tt_; \
  701       checkliveness(L,io_); }
  702 
  703 
  704 /* copy a value from a key */
  705 #define getnodekey(L,obj,node) \
  706     { TValue *io_=(obj); const Node *n_=(node); \
  707       io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \
  708       checkliveness(L,io_); }
  709 
  710 
  711 /*
  712 ** About 'alimit': if 'isrealasize(t)' is true, then 'alimit' is the
  713 ** real size of 'array'. Otherwise, the real size of 'array' is the
  714 ** smallest power of two not smaller than 'alimit' (or zero iff 'alimit'
  715 ** is zero); 'alimit' is then used as a hint for #t.
  716 */
  717 
  718 #define BITRAS      (1 << 7)
  719 #define isrealasize(t)      (!((t)->flags & BITRAS))
  720 #define setrealasize(t)     ((t)->flags &= cast_byte(~BITRAS))
  721 #define setnorealasize(t)   ((t)->flags |= BITRAS)
  722 
  723 
  724 typedef struct Table {
  725   CommonHeader;
  726   lu_byte flags;  /* 1<<p means tagmethod(p) is not present */
  727   lu_byte lsizenode;  /* log2 of size of 'node' array */
  728   unsigned int alimit;  /* "limit" of 'array' array */
  729   TValue *array;  /* array part */
  730   Node *node;
  731   Node *lastfree;  /* any free position is before this position */
  732   struct Table *metatable;
  733   GCObject *gclist;
  734 } Table;
  735 
  736 
  737 /*
  738 ** Macros to manipulate keys inserted in nodes
  739 */
  740 #define keytt(node)     ((node)->u.key_tt)
  741 #define keyval(node)        ((node)->u.key_val)
  742 
  743 #define keyisnil(node)      (keytt(node) == LUA_TNIL)
  744 #define keyisinteger(node)  (keytt(node) == LUA_VNUMINT)
  745 #define keyival(node)       (keyval(node).i)
  746 #define keyisshrstr(node)   (keytt(node) == ctb(LUA_VSHRSTR))
  747 #define keystrval(node)     (gco2ts(keyval(node).gc))
  748 
  749 #define setnilkey(node)     (keytt(node) = LUA_TNIL)
  750 
  751 #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE)
  752 
  753 #define gckey(n)    (keyval(n).gc)
  754 #define gckeyN(n)   (keyiscollectable(n) ? gckey(n) : NULL)
  755 
  756 
  757 /*
  758 ** Dead keys in tables have the tag DEADKEY but keep their original
  759 ** gcvalue. This distinguishes them from regular keys but allows them to
  760 ** be found when searched in a special way. ('next' needs that to find
  761 ** keys removed from a table during a traversal.)
  762 */
  763 #define setdeadkey(node)    (keytt(node) = LUA_TDEADKEY)
  764 #define keyisdead(node)     (keytt(node) == LUA_TDEADKEY)
  765 
  766 /* }================================================================== */
  767 
  768 
  769 
  770 /*
  771 ** 'module' operation for hashing (size is always a power of 2)
  772 */
  773 #define lmod(s,size) \
  774     (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1)))))
  775 
  776 
  777 #define twoto(x)    (1<<(x))
  778 #define sizenode(t) (twoto((t)->lsizenode))
  779 
  780 
  781 /* size of buffer for 'luaO_utf8esc' function */
  782 #define UTF8BUFFSZ  8
  783 
  784 LUAI_FUNC int luaO_utf8esc (char *buff, unsigned long x);
  785 LUAI_FUNC int luaO_ceillog2 (unsigned int x);
  786 LUAI_FUNC int luaO_rawarith (lua_State *L, int op, const TValue *p1,
  787                              const TValue *p2, TValue *res);
  788 LUAI_FUNC void luaO_arith (lua_State *L, int op, const TValue *p1,
  789                            const TValue *p2, StkId res);
  790 LUAI_FUNC size_t luaO_str2num (const char *s, TValue *o);
  791 LUAI_FUNC int luaO_hexavalue (int c);
  792 LUAI_FUNC void luaO_tostring (lua_State *L, TValue *obj);
  793 LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
  794                                                        va_list argp);
  795 LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
  796 LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t srclen);
  797 
  798 
  799 #endif
  800