?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  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 'obj2' to 'obj1') */
  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.  
  801.