← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/lua/src/lobject.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/lua/src/lobject.h
 
1
/*
 
2
** $Id: lobject.h,v 2.71 2012/09/11 18:21:44 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