9
3

lobject.h 21 KB

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