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