src/lua/src/lobject.h

   1 /*
   2 ** $Id: lobject.h,v 2.71.1.1 2013/04/12 18:48:47 roberto Exp $
   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 tags for non-values
  21 */
  22 #define LUA_TPROTO      LUA_NUMTAGS
  23 #define LUA_TUPVAL      (LUA_NUMTAGS+1)
  24 #define LUA_TDEADKEY    (LUA_NUMTAGS+2)
  25
  26 /*
  27 ** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
  28 */
  29 #define LUA_TOTALTAGS   (LUA_TUPVAL+2)
  30
  31
  32 /*
  33 ** tags for Tagged Values have the following use of bits:
  34 ** bits 0-3: actual tag (a LUA_T* value)
  35 ** bits 4-5: variant bits
  36 ** bit 6: whether value is collectable
  37 */
  38
  39 #define VARBITS         (3 << 4)
  40
  41
  42 /*
  43 ** LUA_TFUNCTION variants:
  44 ** 0 - Lua function
  45 ** 1 - light C function
  46 ** 2 - regular C function (closure)
  47 */
  48
  49 /* Variant tags for functions */
  50 #define LUA_TLCL        (LUA_TFUNCTION | (0 << 4))  /* Lua closure */
  51 #define LUA_TLCF        (LUA_TFUNCTION | (1 << 4))  /* light C function */
  52 #define LUA_TCCL        (LUA_TFUNCTION | (2 << 4))  /* C closure */
  53
  54
  55 /* Variant tags for strings */
  56 #define LUA_TSHRSTR     (LUA_TSTRING | (0 << 4))  /* short strings */
  57 #define LUA_TLNGSTR     (LUA_TSTRING | (1 << 4))  /* long strings */
  58
  59
  60 /* Bit mark for collectable types */
  61 #define BIT_ISCOLLECTABLE       (1 << 6)
  62
  63 /* mark a tag as collectable */
  64 #define ctb(t)                  ((t) | BIT_ISCOLLECTABLE)
  65
  66
  67 /*
  68 ** Union of all collectable objects
  69 */
  70 typedef union GCObject GCObject;
  71
  72
  73 /*
  74 ** Common Header for all collectable objects (in macro form, to be
  75 ** included in other objects)
  76 */
  77 #define CommonHeader    GCObject *next; lu_byte tt; lu_byte marked
  78
  79
  80 /*
  81 ** Common header in struct form
  82 */
  83 typedef struct GCheader {
  84   CommonHeader;
  85 } GCheader;
  86
  87
  88
  89 /*
  90 ** Union of all Lua values
  91 */
  92 typedef union Value Value;
  93
  94
  95 #define numfield        lua_Number n;    /* numbers */
  96
  97
  98
  99 /*
 100 ** Tagged Values. This is the basic representation of values in Lua,
 101 ** an actual value plus a tag with its type.
 102 */
 103
 104 #define TValuefields    Value value_; int tt_
 105
 106 typedef struct lua_TValue TValue;
 107
 108
 109 /* macro defining a nil value */
 110 #define NILCONSTANT     {NULL}, LUA_TNIL
 111
 112
 113 #define val_(o)         ((o)->value_)
 114 #define num_(o)         (val_(o).n)
 115
 116
 117 /* raw type tag of a TValue */
 118 #define rttype(o)       ((o)->tt_)
 119
 120 /* tag with no variants (bits 0-3) */
 121 #define novariant(x)    ((x) & 0x0F)
 122
 123 /* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
 124 #define ttype(o)        (rttype(o) & 0x3F)
 125
 126 /* type tag of a TValue with no variants (bits 0-3) */
 127 #define ttypenv(o)      (novariant(rttype(o)))
 128
 129
 130 /* Macros to test type */
 131 #define checktag(o,t)           (rttype(o) == (t))
 132 #define checktype(o,t)          (ttypenv(o) == (t))
 133 #define ttisnumber(o)           checktag((o), LUA_TNUMBER)
 134 #define ttisnil(o)              checktag((o), LUA_TNIL)
 135 #define ttisboolean(o)          checktag((o), LUA_TBOOLEAN)
 136 #define ttislightuserdata(o)    checktag((o), LUA_TLIGHTUSERDATA)
 137 #define ttisstring(o)           checktype((o), LUA_TSTRING)
 138 #define ttisshrstring(o)        checktag((o), ctb(LUA_TSHRSTR))
 139 #define ttislngstring(o)        checktag((o), ctb(LUA_TLNGSTR))
 140 #define ttistable(o)            checktag((o), ctb(LUA_TTABLE))
 141 #define ttisfunction(o)         checktype(o, LUA_TFUNCTION)
 142 #define ttisclosure(o)          ((rttype(o) & 0x1F) == LUA_TFUNCTION)
 143 #define ttisCclosure(o)         checktag((o), ctb(LUA_TCCL))
 144 #define ttisLclosure(o)         checktag((o), ctb(LUA_TLCL))
 145 #define ttislcf(o)              checktag((o), LUA_TLCF)
 146 #define ttisuserdata(o)         checktag((o), ctb(LUA_TUSERDATA))
 147 #define ttisthread(o)           checktag((o), ctb(LUA_TTHREAD))
 148 #define ttisdeadkey(o)          checktag((o), LUA_TDEADKEY)
 149
 150 #define ttisequal(o1,o2)        (rttype(o1) == rttype(o2))
 151
 152 /* Macros to access values */
 153 #define nvalue(o)       check_exp(ttisnumber(o), num_(o))
 154 #define gcvalue(o)      check_exp(iscollectable(o), val_(o).gc)
 155 #define pvalue(o)       check_exp(ttislightuserdata(o), val_(o).p)
 156 #define rawtsvalue(o)   check_exp(ttisstring(o), &val_(o).gc->ts)
 157 #define tsvalue(o)      (&rawtsvalue(o)->tsv)
 158 #define rawuvalue(o)    check_exp(ttisuserdata(o), &val_(o).gc->u)
 159 #define uvalue(o)       (&rawuvalue(o)->uv)
 160 #define clvalue(o)      check_exp(ttisclosure(o), &val_(o).gc->cl)
 161 #define clLvalue(o)     check_exp(ttisLclosure(o), &val_(o).gc->cl.l)
 162 #define clCvalue(o)     check_exp(ttisCclosure(o), &val_(o).gc->cl.c)
 163 #define fvalue(o)       check_exp(ttislcf(o), val_(o).f)
 164 #define hvalue(o)       check_exp(ttistable(o), &val_(o).gc->h)
 165 #define bvalue(o)       check_exp(ttisboolean(o), val_(o).b)
 166 #define thvalue(o)      check_exp(ttisthread(o), &val_(o).gc->th)
 167 /* a dead value may get the 'gc' field, but cannot access its contents */
 168 #define deadvalue(o)    check_exp(ttisdeadkey(o), cast(void *, val_(o).gc))
 169
 170 #define l_isfalse(o)    (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
 171
 172
 173 #define iscollectable(o)        (rttype(o) & BIT_ISCOLLECTABLE)
 174
 175
 176 /* Macros for internal tests */
 177 #define righttt(obj)            (ttype(obj) == gcvalue(obj)->gch.tt)
 178
 179 #define checkliveness(g,obj) \
 180         lua_longassert(!iscollectable(obj) || \
 181                         (righttt(obj) && !isdead(g,gcvalue(obj))))
 182
 183
 184 /* Macros to set values */
 185 #define settt_(o,t)     ((o)->tt_=(t))
 186
 187 #define setnvalue(obj,x) \
 188   { TValue *io=(obj); num_(io)=(x); settt_(io, LUA_TNUMBER); }
 189
 190 #define setnilvalue(obj) settt_(obj, LUA_TNIL)
 191
 192 #define setfvalue(obj,x) \
 193   { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_TLCF); }
 194
 195 #define setpvalue(obj,x) \
 196   { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_TLIGHTUSERDATA); }
 197
 198 #define setbvalue(obj,x) \
 199   { TValue *io=(obj); val_(io).b=(x); settt_(io, LUA_TBOOLEAN); }
 200
 201 #define setgcovalue(L,obj,x) \
 202   { TValue *io=(obj); GCObject *i_g=(x); \
 203     val_(io).gc=i_g; settt_(io, ctb(gch(i_g)->tt)); }
 204
 205 #define setsvalue(L,obj,x) \
 206   { TValue *io=(obj); \
 207     TString *x_ = (x); \
 208     val_(io).gc=cast(GCObject *, x_); settt_(io, ctb(x_->tsv.tt)); \
 209     checkliveness(G(L),io); }
 210
 211 #define setuvalue(L,obj,x) \
 212   { TValue *io=(obj); \
 213     val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TUSERDATA)); \
 214     checkliveness(G(L),io); }
 215
 216 #define setthvalue(L,obj,x) \
 217   { TValue *io=(obj); \
 218     val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTHREAD)); \
 219     checkliveness(G(L),io); }
 220
 221 #define setclLvalue(L,obj,x) \
 222   { TValue *io=(obj); \
 223     val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TLCL)); \
 224     checkliveness(G(L),io); }
 225
 226 #define setclCvalue(L,obj,x) \
 227   { TValue *io=(obj); \
 228     val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TCCL)); \
 229     checkliveness(G(L),io); }
 230
 231 #define sethvalue(L,obj,x) \
 232   { TValue *io=(obj); \
 233     val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTABLE)); \
 234     checkliveness(G(L),io); }
 235
 236 #define setdeadvalue(obj)       settt_(obj, LUA_TDEADKEY)
 237
 238
 239
 240 #define setobj(L,obj1,obj2) \
 241         { const TValue *io2=(obj2); TValue *io1=(obj1); \
 242           io1->value_ = io2->value_; io1->tt_ = io2->tt_; \
 243           checkliveness(G(L),io1); }
 244
 245
 246 /*
 247 ** different types of assignments, according to destination
 248 */
 249
 250 /* from stack to (same) stack */
 251 #define setobjs2s       setobj
 252 /* to stack (not from same stack) */
 253 #define setobj2s        setobj
 254 #define setsvalue2s     setsvalue
 255 #define sethvalue2s     sethvalue
 256 #define setptvalue2s    setptvalue
 257 /* from table to same table */
 258 #define setobjt2t       setobj
 259 /* to table */
 260 #define setobj2t        setobj
 261 /* to new object */
 262 #define setobj2n        setobj
 263 #define setsvalue2n     setsvalue
 264
 265
 266 /* check whether a number is valid (useful only for NaN trick) */
 267 #define luai_checknum(L,o,c)    { /* empty */ }
 268
 269
 270 /*
 271 ** {======================================================
 272 ** NaN Trick
 273 ** =======================================================
 274 */
 275 #if defined(LUA_NANTRICK)
 276
 277 /*
 278 ** numbers are represented in the 'd_' field. All other values have the
 279 ** value (NNMARK | tag) in 'tt__'. A number with such pattern would be
 280 ** a "signaled NaN", which is never generated by regular operations by
 281 ** the CPU (nor by 'strtod')
 282 */
 283
 284 /* allows for external implementation for part of the trick */
 285 #if !defined(NNMARK)    /* { */
 286
 287
 288 #if !defined(LUA_IEEEENDIAN)
 289 #error option 'LUA_NANTRICK' needs 'LUA_IEEEENDIAN'
 290 #endif
 291
 292
 293 #define NNMARK          0x7FF7A500
 294 #define NNMASK          0x7FFFFF00
 295
 296 #undef TValuefields
 297 #undef NILCONSTANT
 298
 299 #if (LUA_IEEEENDIAN == 0)       /* { */
 300
 301 /* little endian */
 302 #define TValuefields  \
 303         union { struct { Value v__; int tt__; } i; double d__; } u
 304 #define NILCONSTANT     {{{NULL}, tag2tt(LUA_TNIL)}}
 305 /* field-access macros */
 306 #define v_(o)           ((o)->u.i.v__)
 307 #define d_(o)           ((o)->u.d__)
 308 #define tt_(o)          ((o)->u.i.tt__)
 309
 310 #else                           /* }{ */
 311
 312 /* big endian */
 313 #define TValuefields  \
 314         union { struct { int tt__; Value v__; } i; double d__; } u
 315 #define NILCONSTANT     {{tag2tt(LUA_TNIL), {NULL}}}
 316 /* field-access macros */
 317 #define v_(o)           ((o)->u.i.v__)
 318 #define d_(o)           ((o)->u.d__)
 319 #define tt_(o)          ((o)->u.i.tt__)
 320
 321 #endif                          /* } */
 322
 323 #endif                  /* } */
 324
 325
 326 /* correspondence with standard representation */
 327 #undef val_
 328 #define val_(o)         v_(o)
 329 #undef num_
 330 #define num_(o)         d_(o)
 331
 332
 333 #undef numfield
 334 #define numfield        /* no such field; numbers are the entire struct */
 335
 336 /* basic check to distinguish numbers from non-numbers */
 337 #undef ttisnumber
 338 #define ttisnumber(o)   ((tt_(o) & NNMASK) != NNMARK)
 339
 340 #define tag2tt(t)       (NNMARK | (t))
 341
 342 #undef rttype
 343 #define rttype(o)       (ttisnumber(o) ? LUA_TNUMBER : tt_(o) & 0xff)
 344
 345 #undef settt_
 346 #define settt_(o,t)     (tt_(o) = tag2tt(t))
 347
 348 #undef setnvalue
 349 #define setnvalue(obj,x) \
 350         { TValue *io_=(obj); num_(io_)=(x); lua_assert(ttisnumber(io_)); }
 351
 352 #undef setobj
 353 #define setobj(L,obj1,obj2) \
 354         { const TValue *o2_=(obj2); TValue *o1_=(obj1); \
 355           o1_->u = o2_->u; \
 356           checkliveness(G(L),o1_); }
 357
 358
 359 /*
 360 ** these redefinitions are not mandatory, but these forms are more efficient
 361 */
 362
 363 #undef checktag
 364 #undef checktype
 365 #define checktag(o,t)   (tt_(o) == tag2tt(t))
 366 #define checktype(o,t)  (ctb(tt_(o) | VARBITS) == ctb(tag2tt(t) | VARBITS))
 367
 368 #undef ttisequal
 369 #define ttisequal(o1,o2)  \
 370         (ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2)))
 371
 372
 373 #undef luai_checknum
 374 #define luai_checknum(L,o,c)    { if (!ttisnumber(o)) c; }
 375
 376 #endif
 377 /* }====================================================== */
 378
 379
 380
 381 /*
 382 ** {======================================================
 383 ** types and prototypes
 384 ** =======================================================
 385 */
 386
 387
 388 union Value {
 389   GCObject *gc;    /* collectable objects */
 390   void *p;         /* light userdata */
 391   int b;           /* booleans */
 392   lua_CFunction f; /* light C functions */
 393   numfield         /* numbers */
 394 };
 395
 396
 397 struct lua_TValue {
 398   TValuefields;
 399 };
 400
 401
 402 typedef TValue *StkId;  /* index to stack elements */
 403
 404
 405
 406
 407 /*
 408 ** Header for string value; string bytes follow the end of this structure
 409 */
 410 typedef union TString {
 411   L_Umaxalign dummy;  /* ensures maximum alignment for strings */
 412   struct {
 413     CommonHeader;
 414     lu_byte extra;  /* reserved words for short strings; "has hash" for longs */
 415     unsigned int hash;
 416     size_t len;  /* number of characters in string */
 417   } tsv;
 418 } TString;
 419
 420
 421 /* get the actual string (array of bytes) from a TString */
 422 #define getstr(ts)      cast(const char *, (ts) + 1)
 423
 424 /* get the actual string (array of bytes) from a Lua value */
 425 #define svalue(o)       getstr(rawtsvalue(o))
 426
 427
 428 /*
 429 ** Header for userdata; memory area follows the end of this structure
 430 */
 431 typedef union Udata {
 432   L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
 433   struct {
 434     CommonHeader;
 435     struct Table *metatable;
 436     struct Table *env;
 437     size_t len;  /* number of bytes */
 438   } uv;
 439 } Udata;
 440
 441
 442
 443 /*
 444 ** Description of an upvalue for function prototypes
 445 */
 446 typedef struct Upvaldesc {
 447   TString *name;  /* upvalue name (for debug information) */
 448   lu_byte instack;  /* whether it is in stack */
 449   lu_byte idx;  /* index of upvalue (in stack or in outer function's list) */
 450 } Upvaldesc;
 451
 452
 453 /*
 454 ** Description of a local variable for function prototypes
 455 ** (used for debug information)
 456 */
 457 typedef struct LocVar {
 458   TString *varname;
 459   int startpc;  /* first point where variable is active */
 460   int endpc;    /* first point where variable is dead */
 461 } LocVar;
 462
 463
 464 /*
 465 ** Function Prototypes
 466 */
 467 typedef struct Proto {
 468   CommonHeader;
 469   TValue *k;  /* constants used by the function */
 470   Instruction *code;
 471   struct Proto **p;  /* functions defined inside the function */
 472   int *lineinfo;  /* map from opcodes to source lines (debug information) */
 473   LocVar *locvars;  /* information about local variables (debug information) */
 474   Upvaldesc *upvalues;  /* upvalue information */
 475   union Closure *cache;  /* last created closure with this prototype */
 476   TString  *source;  /* used for debug information */
 477   int sizeupvalues;  /* size of 'upvalues' */
 478   int sizek;  /* size of `k' */
 479   int sizecode;
 480   int sizelineinfo;
 481   int sizep;  /* size of `p' */
 482   int sizelocvars;
 483   int linedefined;
 484   int lastlinedefined;
 485   GCObject *gclist;
 486   lu_byte numparams;  /* number of fixed parameters */
 487   lu_byte is_vararg;
 488   lu_byte maxstacksize;  /* maximum stack used by this function */
 489 } Proto;
 490
 491
 492
 493 /*
 494 ** Lua Upvalues
 495 */
 496 typedef struct UpVal {
 497   CommonHeader;
 498   TValue *v;  /* points to stack or to its own value */
 499   union {
 500     TValue value;  /* the value (when closed) */
 501     struct {  /* double linked list (when open) */
 502       struct UpVal *prev;
 503       struct UpVal *next;
 504     } l;
 505   } u;
 506 } UpVal;
 507
 508
 509 /*
 510 ** Closures
 511 */
 512
 513 #define ClosureHeader \
 514         CommonHeader; lu_byte nupvalues; GCObject *gclist
 515
 516 typedef struct CClosure {
 517   ClosureHeader;
 518   lua_CFunction f;
 519   TValue upvalue[1];  /* list of upvalues */
 520 } CClosure;
 521
 522
 523 typedef struct LClosure {
 524   ClosureHeader;
 525   struct Proto *p;
 526   UpVal *upvals[1];  /* list of upvalues */
 527 } LClosure;
 528
 529
 530 typedef union Closure {
 531   CClosure c;
 532   LClosure l;
 533 } Closure;
 534
 535
 536 #define isLfunction(o)  ttisLclosure(o)
 537
 538 #define getproto(o)     (clLvalue(o)->p)
 539
 540
 541 /*
 542 ** Tables
 543 */
 544
 545 typedef union TKey {
 546   struct {
 547     TValuefields;
 548     struct Node *next;  /* for chaining */
 549   } nk;
 550   TValue tvk;
 551 } TKey;
 552
 553
 554 typedef struct Node {
 555   TValue i_val;
 556   TKey i_key;
 557 } Node;
 558
 559
 560 typedef struct Table {
 561   CommonHeader;
 562   lu_byte flags;  /* 1<<p means tagmethod(p) is not present */
 563   lu_byte lsizenode;  /* log2 of size of `node' array */
 564   struct Table *metatable;
 565   TValue *array;  /* array part */
 566   Node *node;
 567   Node *lastfree;  /* any free position is before this position */
 568   GCObject *gclist;
 569   int sizearray;  /* size of `array' array */
 570 } Table;
 571
 572
 573
 574 /*
 575 ** `module' operation for hashing (size is always a power of 2)
 576 */
 577 #define lmod(s,size) \
 578         (check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1)))))
 579
 580
 581 #define twoto(x)        (1<<(x))
 582 #define sizenode(t)     (twoto((t)->lsizenode))
 583
 584
 585 /*
 586 ** (address of) a fixed nil value
 587 */
 588 #define luaO_nilobject          (&luaO_nilobject_)
 589
 590
 591 LUAI_DDEC const TValue luaO_nilobject_;
 592
 593
 594 LUAI_FUNC int luaO_int2fb (unsigned int x);
 595 LUAI_FUNC int luaO_fb2int (int x);
 596 LUAI_FUNC int luaO_ceillog2 (unsigned int x);
 597 LUAI_FUNC lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2);
 598 LUAI_FUNC int luaO_str2d (const char *s, size_t len, lua_Number *result);
 599 LUAI_FUNC int luaO_hexavalue (int c);
 600 LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
 601                                                        va_list argp);
 602 LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
 603 LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);
 604
 605
 606 #endif
 607