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.

L0360 #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

Lua 5.1.4: lobject.h