Lua 5.1.4: lobject.h

This files provides the types an operations on for handling values (TValue objects) in Lua.
L0001 /* L0002 ** $Id: lobject.h,v 2008/08/06 13:29:48 roberto Exp $ L0003 ** Type definitions for Lua objects L0004 ** See Copyright Notice in lua.h L0005 */ L0006 L0007 L0008 #ifndef lobject_h L0009 #define lobject_h L0010 L0011 L0012 #include <stdarg.h> L0013 L0014 L0015 #include "llimits.h" L0016 #include "lua.h" L0017 L0018 L0019 /* tags for values visible from Lua */ L0020 #define LAST_TAG LUA_TTHREAD L0021 L0022 #define NUM_TAGS (LAST_TAG+1) L0023 L0024 L0025 /* L0026 ** Extra tags for non-values L0027 */ L0028 #define LUA_TPROTO (LAST_TAG+1) L0029 #define LUA_TUPVAL (LAST_TAG+2) L0030 #define LUA_TDEADKEY (LAST_TAG+3) L0031 L0032 L0033 /* L0034 ** Union of all collectable objects L0035 */ L0036 typedef union GCObject GCObject; L0037 L0038 L0039 /* L0040 ** Common Header for all collectable objects (in macro form, to be L0041 ** included in other objects) L0042 */ L0043 #define CommonHeader GCObject *next; lu_byte tt; lu_byte marked L0044 L0045 L0046 /* L0047 ** Common header in struct form L0048 */ L0049 typedef struct GCheader { L0050 CommonHeader; L0051 } GCheader; L0052 L0053 L0054 L0055 L0056 /* L0057 ** Union of all Lua values L0058 */ L0059 typedef union { L0060 GCObject *gc; L0061 void *p; L0062 lua_Number n; L0063 int b; L0064 } Value; L0065 L0066 L0067 /* L0068 ** Tagged Values L0069 */ L0070 L0071 #define TValuefields Value value; int tt L0072 L0073 typedef struct lua_TValue { L0074 TValuefields; L0075 } TValue; L0076 L0077 L0078 /* Macros to test type */ L0079 #define ttisnil(o) (ttype(o) == LUA_TNIL)
Checks whether TValue o is nil.
#define ttisnumber(o) (ttype(o) == LUA_TNUMBER)
Checks whether TValue o is of type number.
#define ttisstring(o) (ttype(o) == LUA_TSTRING) L0082 #define ttistable(o) (ttype(o) == LUA_TTABLE) L0083 #define ttisfunction(o) (ttype(o) == LUA_TFUNCTION) L0084 #define ttisboolean(o) (ttype(o) == LUA_TBOOLEAN) L0085 #define ttisuserdata(o) (ttype(o) == LUA_TUSERDATA) L0086 #define ttisthread(o) (ttype(o) == LUA_TTHREAD) L0087 #define ttislightuserdata(o) (ttype(o) == LUA_TLIGHTUSERDATA) L0088 L0089 /* Macros to access values */ L0090 #define ttype(o) ((o)->tt) L0091 #define gcvalue(o) check_exp(iscollectable(o), (o)->value.gc) L0092 #define pvalue(o) check_exp(ttislightuserdata(o), (o)->value.p)
Gets void pointer in TValue o.
#define nvalue(o) check_exp(ttisnumber(o), (o)->value.n)
Gets number (lua_Number) in TValue o (or asserts if not number).
#define rawtsvalue(o) check_exp(ttisstring(o), &(o)->value.gc->ts)
Gets string (TString) in TValue o.
#define tsvalue(o) (&rawtsvalue(o)->tsv)
Gets string header (TString.tsv) in TValue o.
#define rawuvalue(o) check_exp(ttisuserdata(o), &(o)->value.gc->u) L0097 #define uvalue(o) (&rawuvalue(o)->uv)
Gets userdata header (Udata.uv) in TValue o.
#define clvalue(o) check_exp(ttisfunction(o), &(o)->value.gc->cl)
Gets closure (Closure - in TValue o.
#define hvalue(o) check_exp(ttistable(o), &(o)->value.gc->h)
Gets table (Table - GCobject.h) in TValue o.
#define bvalue(o) check_exp(ttisboolean(o), (o)->value.b)
Gets boolean (int) value in TValue o.
#define thvalue(o) check_exp(ttisthread(o), &(o)->value.gc->th)
Gets thread lua_State ( value in Tvalue o.
L0102 L0103
#define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
Gets whether TValue o evaluates to false (i.e. is nil or false).
L0104 L0105 /* L0106 ** for internal debug only L0107 */ L0108
#define checkconsistency(obj) \ L0109 lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc-> L0110 L0111 #define checkliveness(g,obj) \ L0112 lua_assert(!iscollectable(obj) || \ L0113 ((ttype(obj) == (obj)->value.gc-> && !isdead(g, (obj)->value.gc))) L0114 L0115 L0116 /* Macros to set values */ L0117 #define setnilvalue(obj) ((obj)->tt=LUA_TNIL) L0118 L0119 #define setnvalue(obj,x) \ L0120 { TValue *i_o=(obj); i_o->value.n=(x); i_o->tt=LUA_TNUMBER; }
Sets value of TValue obj to number (lua_Number) x.
L0121 L0122
#define setpvalue(obj,x) \ L0123 { TValue *i_o=(obj); i_o->value.p=(x); i_o->tt=LUA_TLIGHTUSERDATA; } L0124 L0125 #define setbvalue(obj,x) \ L0126 { TValue *i_o=(obj); i_o->value.b=(x); i_o->tt=LUA_TBOOLEAN; }
Sets value of TValue obj to boolean (int 0..1) x.
L0127 L0128
#define setsvalue(L,obj,x) \ L0129 { TValue *i_o=(obj); \ L0130 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TSTRING; \ L0131 checkliveness(G(L),i_o); } L0132 L0133 #define setuvalue(L,obj,x) \ L0134 { TValue *i_o=(obj); \ L0135 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TUSERDATA; \ L0136 checkliveness(G(L),i_o); } L0137 L0138 #define setthvalue(L,obj,x) \ L0139 { TValue *i_o=(obj); \ L0140 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTHREAD; \ L0141 checkliveness(G(L),i_o); } L0142 L0143 #define setclvalue(L,obj,x) \ L0144 { TValue *i_o=(obj); \ L0145 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TFUNCTION; \ L0146 checkliveness(G(L),i_o); } L0147 L0148 #define sethvalue(L,obj,x) \ L0149 { TValue *i_o=(obj); \ L0150 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTABLE; \ L0151 checkliveness(G(L),i_o); } L0152 L0153 #define setptvalue(L,obj,x) \ L0154 { TValue *i_o=(obj); \ L0155 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TPROTO; \ L0156 checkliveness(G(L),i_o); } L0157 L0158 L0159 L0160 L0161 #define setobj(L,obj1,obj2) \ L0162 { const TValue *o2=(obj2); TValue *o1=(obj1); \ L0163 o1->value = o2->value; o1->tt=o2->tt; \ L0164 checkliveness(G(L),o1); } L0165 L0166 L0167 /* L0168 ** different types of sets, according to destination L0169 */ L0170 L0171 /* from stack to (same) stack */ L0172 #define setobjs2s setobj L0173 /* to stack (not from same stack) */ L0174 #define setobj2s setobj L0175 #define setsvalue2s setsvalue L0176 #define sethvalue2s sethvalue L0177 #define setptvalue2s setptvalue L0178 /* from table to same table */ L0179 #define setobjt2t setobj L0180 /* to table */ L0181 #define setobj2t setobj L0182 /* to new object */ L0183 #define setobj2n setobj L0184 #define setsvalue2n setsvalue L0185 L0186 #define setttype(obj, tt) (ttype(obj) = (tt)) L0187 L0188 L0189 #define iscollectable(o) (ttype(o) >= LUA_TSTRING) L0190 L0191 L0192 L0193 typedef TValue *StkId; /* index to stack elements */ L0194 L0195 L0196 /* L0197 ** String headers for string table L0198 */ L0199 typedef union TString { L0200 L_Umaxalign dummy; /* ensures maximum alignment for strings */ L0201 struct { L0202 CommonHeader; L0203 lu_byte reserved; L0204 unsigned int hash; L0205 size_t len; L0206 } tsv; L0207 } TString; L0208 L0209 L0210 #define getstr(ts) cast(const char *, (ts) + 1) L0211 #define svalue(o) getstr(rawtsvalue(o))
Note: TValue o -> const char *.
L0212 L0213 L0214 L0215 typedef union
Udata {
Note: each (heavyweight) userdata can be associated with a metatable and a user value (previously called a "userdata environment table") set via lua_setuservalue. A userdata is garbage collectable CommonHeader) and is allocated as a series of `len` bytes in Lua's own memory.
L0216 L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */ L0217 struct { L0218 CommonHeader; L0219 struct Table *metatable; L0220 struct Table *env; L0221 size_t len; L0222 } uv; L0223 } Udata; L0224 L0225 L0226 L0227 L0228 /* L0229 ** Function Prototypes L0230 */ L0231 typedef struct Proto {
Every definition of a Lua function (or C function exposed as a Lua function) is represented with a function prototype object. This contains things like a list of bytecode instructions (code), links to other constant data used by the functions (constants, nested functions, and upvalue descriptions), and other metadata (e.g. debugging info). For each function prototype, any number of values may be instantiated (allocated) based on that prototype. For example, this: local t = {} for i=1,10 do t[i] = function() return i end end creates 10 function objects that all link to the same prototype of "function() return i end".
L0232 CommonHeader; L0233 TValue *k; /* constants used by the function */ L0234 Instruction *code; L0235 struct Proto **p; /* functions defined inside the function */ L0236 int *lineinfo; /* map from opcodes to source lines */ L0237 struct LocVar *locvars; /* information about local variables */ L0238 TString **upvalues; /* upvalue names */ L0239 TString *source; L0240 int sizeupvalues; L0241 int sizek; /* size of `k' */ L0242 int sizecode; L0243 int sizelineinfo; L0244 int sizep; /* size of `p' */ L0245 int sizelocvars; L0246 int linedefined; L0247 int lastlinedefined; L0248 GCObject *gclist; L0249 lu_byte nups; /* number of upvalues */ L0250 lu_byte numparams; L0251 lu_byte is_vararg; L0252 lu_byte maxstacksize; L0253 } Proto; L0254 L0255 L0256 /* masks for new-style vararg */ L0257 #define VARARG_HASARG 1 L0258 #define VARARG_ISVARARG 2 L0259 #define VARARG_NEEDSARG 4 L0260 L0261 L0262 typedef struct LocVar { L0263 TString *varname; L0264 int startpc; /* first point where variable is active */ L0265 int endpc; /* first point where variable is dead */ L0266 } LocVar; L0267 L0268 L0269 L0270 /* L0271 ** Upvalues L0272 */ L0273 L0274 typedef struct UpVal {
This represents upvalues. They are stored in a closure value (LClosure). Compare to Upvaldesc.
L0275 CommonHeader; L0276 TValue *v; /* points to stack or to its own value */ L0277 union { L0278 TValue value; /* the value (when closed) */ L0279 struct { /* double linked list (when open) */ L0280 struct UpVal *prev; L0281 struct UpVal *next; L0282 } l; L0283 } u; L0284 } UpVal; L0285 L0286 L0287 /* L0288 ** Closures L0289 */ L0290 L0291 #define ClosureHeader \ L0292 CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \ L0293 struct Table *env L0294 L0295 typedef struct CClosure { L0296 ClosureHeader; L0297 lua_CFunction f; L0298 TValue upvalue[1]; L0299 } CClosure; L0300 L0301 L0302 typedef struct LClosure { L0303 ClosureHeader; L0304 struct Proto *p; L0305 UpVal *upvals[1]; L0306 } LClosure; L0307 L0308 L0309 typedef union Closure {
Represents a closure (implemented via C Function or Lua function). These are linked to TValue's, among other places.
L0310 CClosure c; L0311 LClosure l; L0312 } Closure; L0313 L0314 L0315 #define iscfunction(o) (ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC) L0316 #define isLfunction(o) (ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC) L0317 L0318 L0319 /* L0320 ** Tables L0321 */ L0322 L0323 typedef union TKey { L0324 struct { L0325 TValuefields; L0326 struct Node *next; /* for chaining */ L0327 } nk; L0328 TValue tvk; L0329 } TKey; L0330 L0331 L0332 typedef struct Node { L0333 TValue i_val; L0334 TKey i_key; L0335 } Node; L0336 L0337 L0338 typedef struct Table {
Represents a Lua table ({}). These are linked to TValues. Note: each table can have an optional metatable and can have an array part (stored in array `array` of length `sizearray` and a hash part (stored in array `node` of length encoded in `lsizenode`). You can quickly check for certain metamethods via the `flags` field rather than looking in the metatable.
L0339 CommonHeader; L0340 lu_byte flags; /* 1<<p means tagmethod(p) is not present */ L0341 lu_byte lsizenode; /* log2 of size of `node' array */ L0342 struct Table *metatable; L0343 TValue *array; /* array part */ L0344 Node *node; L0345 Node *lastfree; /* any free position is before this position */ L0346 GCObject *gclist; L0347 int sizearray; /* size of `array' array */ L0348 } Table; L0349 L0350 L0351 L0352 /* L0353 ** `module' operation for hashing (size is always a power of 2) L0354 */ L0355 #define lmod(s,size) \ L0356 (check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1))))) L0357 L0358 L0359 #define twoto(x) (1<<(x))
Efficiently raises 2 to the integer x power.
#define sizenode(t) (twoto((t)->lsizenode)) L0361 L0362 L0363 #define luaO_nilobject (&luaO_nilobject_) L0364 L0365 LUAI_DATA const TValue luaO_nilobject_; L0366 L0367 #define ceillog2(x) (luaO_log2((x)-1) + 1) L0368 L0369 LUAI_FUNC int luaO_log2 (unsigned int x); L0370 LUAI_FUNC int luaO_int2fb (unsigned int x); L0371 LUAI_FUNC int luaO_fb2int (int x); L0372 LUAI_FUNC int luaO_rawequalObj (const TValue *t1, const TValue *t2); L0373 LUAI_FUNC int luaO_str2d (const char *s, lua_Number *result); L0374 LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt, L0375 va_list argp); L0376 LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...); L0377 LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len); L0378 L0379 L0380 #endif L0381

Generated by pretty.lua