Subversion Repositories Kolibri OS

/*

** $Id: lobject.h,v 2.64 2011/10/31 17:48:22 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

*/

/*

** 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 */

/* 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_)

/* 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)	(rttype(o) & 0x0F)

/* Macros to test type */

#define checktag(o,t)		(rttype(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)		checktag((o), ctb(LUA_TSTRING))

#define ttistable(o)		checktag((o), ctb(LUA_TTABLE))

#define ttisfunction(o)		(ttypenv(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)		(ttypenv(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 changenvalue(o,x)	check_exp(ttisnumber(o), num_(o)=(x))

#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); \

    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TSTRING)); \

    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 setptvalue(L,obj,x) \

  { TValue *io=(obj); \

    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TPROTO)); \

    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

/*

** {======================================================

** NaN Trick

** =======================================================

*/

#if defined(LUA_NANTRICK) \

 || defined(LUA_NANTRICK_LE) \

 || defined(LUA_NANTRICK_BE)

/*

** 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')

*/

#if !defined(NNMARK)

#define NNMARK		0x7FF7A500

#define NNMASK		0x7FFFFF00

#endif

#undef TValuefields

#undef NILCONSTANT

#if defined(LUA_NANTRICK_LE)

/* 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__)

#elif defined(LUA_NANTRICK_BE)

/* 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__)

#elif !defined(TValuefields)

#error option 'LUA_NANTRICK' needs declaration for 'TValuefields'

#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

#define checktag(o,t)	(tt_(o) == tag2tt(t))

#undef ttisequal

#define ttisequal(o1,o2)  \

	(ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2)))

#define luai_checknum(L,o,c)	{ if (!ttisnumber(o)) c; }

#else

#define luai_checknum(L,o,c)	{ /* empty */ }

#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 reserved;

    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 isC; 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<

  lu_byte lsizenode;  /* log2 of size of `node' array */

  struct Table *metatable;

  TValue *array;  /* array part */

  Node *node;

  Node *lastfree;  /* any free position is before this position */

  GCObject *gclist;

  int sizearray;  /* size of `array' array */

} Table;

/*

** `module' operation for hashing (size is always a power of 2)

*/

#define lmod(s,size) \

	(check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1)))))

#define twoto(x)	(1<<(x))

#define sizenode(t)	(twoto((t)->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