/* ** $Id: lobject.h,v 2.71.1.1 2013/04/12 18:48:47 roberto Exp $ ** Type definitions for Lua objects ** See Copyright Notice in lua.h */ #ifndef lobject_h #define lobject_h #include #include "llimits.h" #include "lua.h" /* ** Extra tags for non-values */ #define LUA_TPROTO LUA_NUMTAGS #define LUA_TUPVAL (LUA_NUMTAGS + 1) #define LUA_TDEADKEY (LUA_NUMTAGS + 2) /* ** number of all possible tags (including LUA_TNONE but excluding DEADKEY) */ #define LUA_TOTALTAGS (LUA_TUPVAL + 2) /* ** tags for Tagged Values have the following use of bits: ** bits 0-3: actual tag (a LUA_T* value) ** bits 4-5: variant bits ** bit 6: whether value is collectable */ #define VARBITS (3 << 4) /* ** LUA_TFUNCTION variants: ** 0 - Lua function ** 1 - light C function ** 2 - regular C function (closure) */ /* Variant tags for functions */ #define LUA_TLCL (LUA_TFUNCTION | (0 << 4)) /* Lua closure */ #define LUA_TLCF (LUA_TFUNCTION | (1 << 4)) /* light C function */ #define LUA_TCCL (LUA_TFUNCTION | (2 << 4)) /* C closure */ /* Variant tags for strings */ #define LUA_TSHRSTR (LUA_TSTRING | (0 << 4)) /* short strings */ #define LUA_TLNGSTR (LUA_TSTRING | (1 << 4)) /* long strings */ /* Bit mark for collectable types */ #define BIT_ISCOLLECTABLE (1 << 6) /* mark a tag as collectable */ #define ctb(t) ((t) | BIT_ISCOLLECTABLE) /* ** Union of all collectable objects */ typedef union GCObject GCObject; /* ** Common Header for all collectable objects (in macro form, to be ** included in other objects) */ #define CommonHeader \ GCObject *next; \ lu_byte tt; \ lu_byte marked /* ** Common header in struct form */ typedef struct GCheader { CommonHeader; } GCheader; /* ** Union of all Lua values */ typedef union Value Value; #define numfield lua_Number n; /* numbers */ /* ** Tagged Values. This is the basic representation of values in Lua, ** an actual value plus a tag with its type. */ #define TValuefields \ Value value_; \ int tt_ typedef struct lua_TValue TValue; /* macro defining a nil value */ #define NILCONSTANT {NULL}, LUA_TNIL #define val_(o) ((o)->value_) #define num_(o) (val_(o).n) /* raw type tag of a TValue */ #define rttype(o) ((o)->tt_) /* tag with no variants (bits 0-3) */ #define novariant(x) ((x)&0x0F) /* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */ #define ttype(o) (rttype(o) & 0x3F) /* type tag of a TValue with no variants (bits 0-3) */ #define ttypenv(o) (novariant(rttype(o))) /* Macros to test type */ #define checktag(o, t) (rttype(o) == (t)) #define checktype(o, t) (ttypenv(o) == (t)) #define ttisnumber(o) checktag((o), LUA_TNUMBER) #define ttisnil(o) checktag((o), LUA_TNIL) #define ttisboolean(o) checktag((o), LUA_TBOOLEAN) #define ttislightuserdata(o) checktag((o), LUA_TLIGHTUSERDATA) #define ttisstring(o) checktype((o), LUA_TSTRING) #define ttisshrstring(o) checktag((o), ctb(LUA_TSHRSTR)) #define ttislngstring(o) checktag((o), ctb(LUA_TLNGSTR)) #define ttistable(o) checktag((o), ctb(LUA_TTABLE)) #define ttisfunction(o) checktype(o, LUA_TFUNCTION) #define ttisclosure(o) ((rttype(o) & 0x1F) == LUA_TFUNCTION) #define ttisCclosure(o) checktag((o), ctb(LUA_TCCL)) #define ttisLclosure(o) checktag((o), ctb(LUA_TLCL)) #define ttislcf(o) checktag((o), LUA_TLCF) #define ttisuserdata(o) checktag((o), ctb(LUA_TUSERDATA)) #define ttisthread(o) checktag((o), ctb(LUA_TTHREAD)) #define ttisdeadkey(o) checktag((o), LUA_TDEADKEY) #define ttisequal(o1, o2) (rttype(o1) == rttype(o2)) /* Macros to access values */ #define nvalue(o) check_exp(ttisnumber(o), num_(o)) #define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) #define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) #define rawtsvalue(o) check_exp(ttisstring(o), &val_(o).gc->ts) #define tsvalue(o) (&rawtsvalue(o)->tsv) #define rawuvalue(o) check_exp(ttisuserdata(o), &val_(o).gc->u) #define uvalue(o) (&rawuvalue(o)->uv) #define clvalue(o) check_exp(ttisclosure(o), &val_(o).gc->cl) #define clLvalue(o) check_exp(ttisLclosure(o), &val_(o).gc->cl.l) #define clCvalue(o) check_exp(ttisCclosure(o), &val_(o).gc->cl.c) #define fvalue(o) check_exp(ttislcf(o), val_(o).f) #define hvalue(o) check_exp(ttistable(o), &val_(o).gc->h) #define bvalue(o) check_exp(ttisboolean(o), val_(o).b) #define thvalue(o) check_exp(ttisthread(o), &val_(o).gc->th) /* a dead value may get the 'gc' field, but cannot access its contents */ #define deadvalue(o) check_exp(ttisdeadkey(o), cast(void *, val_(o).gc)) #define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0)) #define iscollectable(o) (rttype(o) & BIT_ISCOLLECTABLE) /* Macros for internal tests */ #define righttt(obj) (ttype(obj) == gcvalue(obj)->gch.tt) #define checkliveness(g, obj) \ lua_longassert(!iscollectable(obj) || \ (righttt(obj) && !isdead(g, gcvalue(obj)))) /* Macros to set values */ #define settt_(o, t) ((o)->tt_ = (t)) #define setnvalue(obj, x) \ { \ TValue *io = (obj); \ num_(io) = (x); \ settt_(io, LUA_TNUMBER); \ } #define setnilvalue(obj) settt_(obj, LUA_TNIL) #define setfvalue(obj, x) \ { \ TValue *io = (obj); \ val_(io).f = (x); \ settt_(io, LUA_TLCF); \ } #define setpvalue(obj, x) \ { \ TValue *io = (obj); \ val_(io).p = (x); \ settt_(io, LUA_TLIGHTUSERDATA); \ } #define setbvalue(obj, x) \ { \ TValue *io = (obj); \ val_(io).b = (x); \ settt_(io, LUA_TBOOLEAN); \ } #define setgcovalue(L, obj, x) \ { \ TValue *io = (obj); \ GCObject *i_g = (x); \ val_(io).gc = i_g; \ settt_(io, ctb(gch(i_g)->tt)); \ } #define setsvalue(L, obj, x) \ { \ TValue *io = (obj); \ TString *x_ = (x); \ val_(io).gc = cast(GCObject *, x_); \ settt_(io, ctb(x_->tsv.tt)); \ checkliveness(G(L), io); \ } #define setuvalue(L, obj, x) \ { \ TValue *io = (obj); \ val_(io).gc = cast(GCObject *, (x)); \ settt_(io, ctb(LUA_TUSERDATA)); \ checkliveness(G(L), io); \ } #define setthvalue(L, obj, x) \ { \ TValue *io = (obj); \ val_(io).gc = cast(GCObject *, (x)); \ settt_(io, ctb(LUA_TTHREAD)); \ checkliveness(G(L), io); \ } #define setclLvalue(L, obj, x) \ { \ TValue *io = (obj); \ val_(io).gc = cast(GCObject *, (x)); \ settt_(io, ctb(LUA_TLCL)); \ checkliveness(G(L), io); \ } #define setclCvalue(L, obj, x) \ { \ TValue *io = (obj); \ val_(io).gc = cast(GCObject *, (x)); \ settt_(io, ctb(LUA_TCCL)); \ checkliveness(G(L), io); \ } #define sethvalue(L, obj, x) \ { \ TValue *io = (obj); \ val_(io).gc = cast(GCObject *, (x)); \ settt_(io, ctb(LUA_TTABLE)); \ checkliveness(G(L), io); \ } #define setdeadvalue(obj) settt_(obj, LUA_TDEADKEY) #define setobj(L, obj1, obj2) \ { \ const TValue *io2 = (obj2); \ TValue *io1 = (obj1); \ io1->value_ = io2->value_; \ io1->tt_ = io2->tt_; \ checkliveness(G(L), io1); \ } /* ** different types of assignments, according to destination */ /* from stack to (same) stack */ #define setobjs2s setobj /* to stack (not from same stack) */ #define setobj2s setobj #define setsvalue2s setsvalue #define sethvalue2s sethvalue #define setptvalue2s setptvalue /* from table to same table */ #define setobjt2t setobj /* to table */ #define setobj2t setobj /* to new object */ #define setobj2n setobj #define setsvalue2n setsvalue /* check whether a number is valid (useful only for NaN trick) */ #define luai_checknum(L, o, c) \ { /* empty */ \ } /* ** {====================================================== ** NaN Trick ** ======================================================= */ #if defined(LUA_NANTRICK) /* ** numbers are represented in the 'd_' field. All other values have the ** value (NNMARK | tag) in 'tt__'. A number with such pattern would be ** a "signaled NaN", which is never generated by regular operations by ** the CPU (nor by 'strtod') */ /* allows for external implementation for part of the trick */ #if !defined(NNMARK) /* { */ #if !defined(LUA_IEEEENDIAN) #error option 'LUA_NANTRICK' needs 'LUA_IEEEENDIAN' #endif #define NNMARK 0x7FF7A500 #define NNMASK 0x7FFFFF00 #undef TValuefields #undef NILCONSTANT #if (LUA_IEEEENDIAN == 0) /* { */ /* little endian */ #define TValuefields \ union { \ struct \ { \ Value v__; \ int tt__; \ } i; \ double d__; \ } u #define NILCONSTANT \ { \ { \ {NULL}, tag2tt(LUA_TNIL) \ } \ } /* field-access macros */ #define v_(o) ((o)->u.i.v__) #define d_(o) ((o)->u.d__) #define tt_(o) ((o)->u.i.tt__) #else /* }{ */ /* big endian */ #define TValuefields \ union { \ struct \ { \ int tt__; \ Value v__; \ } i; \ double d__; \ } u #define NILCONSTANT \ { \ { \ tag2tt(LUA_TNIL), { NULL } \ } \ } /* field-access macros */ #define v_(o) ((o)->u.i.v__) #define d_(o) ((o)->u.d__) #define tt_(o) ((o)->u.i.tt__) #endif /* } */ #endif /* } */ /* correspondence with standard representation */ #undef val_ #define val_(o) v_(o) #undef num_ #define num_(o) d_(o) #undef numfield #define numfield /* no such field; numbers are the entire struct */ /* basic check to distinguish numbers from non-numbers */ #undef ttisnumber #define ttisnumber(o) ((tt_(o) & NNMASK) != NNMARK) #define tag2tt(t) (NNMARK | (t)) #undef rttype #define rttype(o) (ttisnumber(o) ? LUA_TNUMBER : tt_(o) & 0xff) #undef settt_ #define settt_(o, t) (tt_(o) = tag2tt(t)) #undef setnvalue #define setnvalue(obj, x) \ { \ TValue *io_ = (obj); \ num_(io_) = (x); \ lua_assert(ttisnumber(io_)); \ } #undef setobj #define setobj(L, obj1, obj2) \ { \ const TValue *o2_ = (obj2); \ TValue *o1_ = (obj1); \ o1_->u = o2_->u; \ checkliveness(G(L), o1_); \ } /* ** these redefinitions are not mandatory, but these forms are more efficient */ #undef checktag #undef checktype #define checktag(o, t) (tt_(o) == tag2tt(t)) #define checktype(o, t) (ctb(tt_(o) | VARBITS) == ctb(tag2tt(t) | VARBITS)) #undef ttisequal #define ttisequal(o1, o2) \ (ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2))) #undef luai_checknum #define luai_checknum(L, o, c) \ { \ if (!ttisnumber(o)) c; \ } #endif /* }====================================================== */ /* ** {====================================================== ** types and prototypes ** ======================================================= */ union Value { GCObject *gc; /* collectable objects */ void *p; /* light userdata */ int b; /* booleans */ lua_CFunction f; /* light C functions */ numfield /* numbers */ }; struct lua_TValue { TValuefields; }; typedef TValue *StkId; /* index to stack elements */ /* ** Header for string value; string bytes follow the end of this structure */ typedef union TString { L_Umaxalign dummy; /* ensures maximum alignment for strings */ struct { CommonHeader; lu_byte extra; /* reserved words for short strings; "has hash" for longs */ unsigned int hash; size_t len; /* number of characters in string */ } tsv; } TString; /* get the actual string (array of bytes) from a TString */ #define getstr(ts) cast(const char *, (ts) + 1) /* get the actual string (array of bytes) from a Lua value */ #define svalue(o) getstr(rawtsvalue(o)) /* ** Header for userdata; memory area follows the end of this structure */ typedef union Udata { L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */ struct { CommonHeader; struct Table *metatable; struct Table *env; size_t len; /* number of bytes */ } uv; } Udata; /* ** Description of an upvalue for function prototypes */ typedef struct Upvaldesc { TString *name; /* upvalue name (for debug information) */ lu_byte instack; /* whether it is in stack */ lu_byte idx; /* index of upvalue (in stack or in outer function's list) */ } Upvaldesc; /* ** Description of a local variable for function prototypes ** (used for debug information) */ typedef struct LocVar { TString *varname; int startpc; /* first point where variable is active */ int endpc; /* first point where variable is dead */ } LocVar; /* ** Function Prototypes */ typedef struct Proto { CommonHeader; TValue *k; /* constants used by the function */ Instruction *code; struct Proto **p; /* functions defined inside the function */ int *lineinfo; /* map from opcodes to source lines (debug information) */ LocVar *locvars; /* information about local variables (debug information) */ Upvaldesc *upvalues; /* upvalue information */ union Closure *cache; /* last created closure with this prototype */ TString *source; /* used for debug information */ int sizeupvalues; /* size of 'upvalues' */ int sizek; /* size of `k' */ int sizecode; int sizelineinfo; int sizep; /* size of `p' */ int sizelocvars; int linedefined; int lastlinedefined; GCObject *gclist; lu_byte numparams; /* number of fixed parameters */ lu_byte is_vararg; lu_byte maxstacksize; /* maximum stack used by this function */ } Proto; /* ** Lua Upvalues */ typedef struct UpVal { CommonHeader; TValue *v; /* points to stack or to its own value */ union { TValue value; /* the value (when closed) */ struct { /* double linked list (when open) */ struct UpVal *prev; struct UpVal *next; } l; } u; } UpVal; /* ** Closures */ #define ClosureHeader \ CommonHeader; \ lu_byte nupvalues; \ GCObject *gclist typedef struct CClosure { ClosureHeader; lua_CFunction f; TValue upvalue[1]; /* list of upvalues */ } CClosure; typedef struct LClosure { ClosureHeader; struct Proto *p; UpVal *upvals[1]; /* list of upvalues */ } LClosure; typedef union Closure { CClosure c; LClosure l; } Closure; #define isLfunction(o) ttisLclosure(o) #define getproto(o) (clLvalue(o)->p) /* ** Tables */ typedef union TKey { struct { TValuefields; struct Node *next; /* for chaining */ } nk; TValue tvk; } TKey; typedef struct Node { TValue i_val; TKey i_key; } Node; typedef struct Table { CommonHeader; lu_byte flags; /* 1<

lsizenode)) /* ** (address of) a fixed nil value */ #define luaO_nilobject (&luaO_nilobject_) LUAI_DDEC const TValue luaO_nilobject_; LUAI_FUNC int luaO_int2fb(unsigned int x); LUAI_FUNC int luaO_fb2int(int x); LUAI_FUNC int luaO_ceillog2(unsigned int x); LUAI_FUNC lua_Number luaO_arith(int op, lua_Number v1, lua_Number v2); LUAI_FUNC int luaO_str2d(const char *s, size_t len, lua_Number *result); LUAI_FUNC int luaO_hexavalue(int c); LUAI_FUNC const char *luaO_pushvfstring(lua_State *L, const char *fmt, va_list argp); LUAI_FUNC const char *luaO_pushfstring(lua_State *L, const char *fmt, ...); LUAI_FUNC void luaO_chunkid(char *out, const char *source, size_t len); #endif