1/*
2** $Id: luaconf.h $
3** Configuration file for Lua
4** See Copyright Notice in lua.h
5*/
6
7
8#ifndef luaconf_h
9#define luaconf_h
10
11#include <limits.h>
12#include <stddef.h>
13
14
15/*
16** ===================================================================
17** General Configuration File for Lua
18**
19** Some definitions here can be changed externally, through the compiler
20** (e.g., with '-D' options): They are commented out or protected
21** by '#if !defined' guards. However, several other definitions
22** should be changed directly here, either because they affect the
23** Lua ABI (by making the changes here, you ensure that all software
24** connected to Lua, such as C libraries, will be compiled with the same
25** configuration); or because they are seldom changed.
26**
27** Search for "@@" to find all configurable definitions.
28** ===================================================================
29*/
30
31
32/*
33** {====================================================================
34** System Configuration: macros to adapt (if needed) Lua to some
35** particular platform, for instance restricting it to C89.
36** =====================================================================
37*/
38
39/*
40@@ LUA_USE_C89 controls the use of non-ISO-C89 features.
41** Define it if you want Lua to avoid the use of a few C99 features
42** or Windows-specific features on Windows.
43*/
44/* #define LUA_USE_C89 */
45
46
47/*
48** By default, Lua on Windows use (some) specific Windows features
49*/
50#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE)
51#define LUA_USE_WINDOWS /* enable goodies for regular Windows */
52#endif
53
54
55#if defined(LUA_USE_WINDOWS)
56#define LUA_DL_DLL /* enable support for DLL */
57#define LUA_USE_C89 /* broadly, Windows is C89 */
58#endif
59
60
61#if defined(LUA_USE_LINUX)
62#define LUA_USE_POSIX
63#define LUA_USE_DLOPEN /* needs an extra library: -ldl */
64#endif
65
66
67#if defined(LUA_USE_MACOSX)
68#define LUA_USE_POSIX
69#define LUA_USE_DLOPEN /* MacOS does not need -ldl */
70#endif
71
72
73/*
74@@ LUAI_IS32INT is true iff 'int' has (at least) 32 bits.
75*/
76#define LUAI_IS32INT ((UINT_MAX >> 30) >= 3)
77
78/* }================================================================== */
79
80
81
82/*
83** {==================================================================
84** Configuration for Number types. These options should not be
85** set externally, because any other code connected to Lua must
86** use the same configuration.
87** ===================================================================
88*/
89
90/*
91@@ LUA_INT_TYPE defines the type for Lua integers.
92@@ LUA_FLOAT_TYPE defines the type for Lua floats.
93** Lua should work fine with any mix of these options supported
94** by your C compiler. The usual configurations are 64-bit integers
95** and 'double' (the default), 32-bit integers and 'float' (for
96** restricted platforms), and 'long'/'double' (for C compilers not
97** compliant with C99, which may not have support for 'long long').
98*/
99
100/* predefined options for LUA_INT_TYPE */
101#define LUA_INT_INT 1
102#define LUA_INT_LONG 2
103#define LUA_INT_LONGLONG 3
104
105/* predefined options for LUA_FLOAT_TYPE */
106#define LUA_FLOAT_FLOAT 1
107#define LUA_FLOAT_DOUBLE 2
108#define LUA_FLOAT_LONGDOUBLE 3
109
110
111/* Default configuration ('long long' and 'double', for 64-bit Lua) */
112#define LUA_INT_DEFAULT LUA_INT_LONGLONG
113#define LUA_FLOAT_DEFAULT LUA_FLOAT_DOUBLE
114
115
116/*
117@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats.
118*/
119#define LUA_32BITS 0
120
121
122/*
123@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for
124** C89 ('long' and 'double'); Windows always has '__int64', so it does
125** not need to use this case.
126*/
127#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS)
128#define LUA_C89_NUMBERS 1
129#else
130#define LUA_C89_NUMBERS 0
131#endif
132
133
134#if LUA_32BITS /* { */
135/*
136** 32-bit integers and 'float'
137*/
138#if LUAI_IS32INT /* use 'int' if big enough */
139#define LUA_INT_TYPE LUA_INT_INT
140#else /* otherwise use 'long' */
141#define LUA_INT_TYPE LUA_INT_LONG
142#endif
143#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT
144
145#elif LUA_C89_NUMBERS /* }{ */
146/*
147** largest types available for C89 ('long' and 'double')
148*/
149#define LUA_INT_TYPE LUA_INT_LONG
150#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE
151
152#else /* }{ */
153/* use defaults */
154
155#define LUA_INT_TYPE LUA_INT_DEFAULT
156#define LUA_FLOAT_TYPE LUA_FLOAT_DEFAULT
157
158#endif /* } */
159
160
161/* }================================================================== */
162
163
164
165/*
166** {==================================================================
167** Configuration for Paths.
168** ===================================================================
169*/
170
171/*
172** LUA_PATH_SEP is the character that separates templates in a path.
173** LUA_PATH_MARK is the string that marks the substitution points in a
174** template.
175** LUA_EXEC_DIR in a Windows path is replaced by the executable's
176** directory.
177*/
178#define LUA_PATH_SEP ";"
179#define LUA_PATH_MARK "?"
180#define LUA_EXEC_DIR "!"
181
182
183/*
184@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
185** Lua libraries.
186@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
187** C libraries.
188** CHANGE them if your machine has a non-conventional directory
189** hierarchy or if you want to install your libraries in
190** non-conventional directories.
191*/
192
193#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
194#if defined(_WIN32) /* { */
195/*
196** In Windows, any exclamation mark ('!') in the path is replaced by the
197** path of the directory of the executable file of the current process.
198*/
199#define LUA_LDIR "!\\lua\\"
200#define LUA_CDIR "!\\"
201#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\"
202
203#if !defined(LUA_PATH_DEFAULT)
204#define LUA_PATH_DEFAULT \
205 LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \
206 LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \
207 LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \
208 ".\\?.lua;" ".\\?\\init.lua"
209#endif
210
211#if !defined(LUA_CPATH_DEFAULT)
212#define LUA_CPATH_DEFAULT \
213 LUA_CDIR"?.dll;" \
214 LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \
215 LUA_CDIR"loadall.dll;" ".\\?.dll"
216#endif
217
218#else /* }{ */
219
220#define LUA_ROOT "/usr/local/"
221#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/"
222#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/"
223
224#if !defined(LUA_PATH_DEFAULT)
225#define LUA_PATH_DEFAULT \
226 LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \
227 LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \
228 "./?.lua;" "./?/init.lua"
229#endif
230
231#if !defined(LUA_CPATH_DEFAULT)
232#define LUA_CPATH_DEFAULT \
233 LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so"
234#endif
235
236#endif /* } */
237
238
239/*
240@@ LUA_DIRSEP is the directory separator (for submodules).
241** CHANGE it if your machine does not use "/" as the directory separator
242** and is not Windows. (On Windows Lua automatically uses "\".)
243*/
244#if !defined(LUA_DIRSEP)
245
246#if defined(_WIN32)
247#define LUA_DIRSEP "\\"
248#else
249#define LUA_DIRSEP "/"
250#endif
251
252#endif
253
254/* }================================================================== */
255
256
257/*
258** {==================================================================
259** Marks for exported symbols in the C code
260** ===================================================================
261*/
262
263/*
264@@ LUA_API is a mark for all core API functions.
265@@ LUALIB_API is a mark for all auxiliary library functions.
266@@ LUAMOD_API is a mark for all standard library opening functions.
267** CHANGE them if you need to define those functions in some special way.
268** For instance, if you want to create one Windows DLL with the core and
269** the libraries, you may want to use the following definition (define
270** LUA_BUILD_AS_DLL to get it).
271*/
272#if defined(LUA_BUILD_AS_DLL) /* { */
273
274#if defined(LUA_CORE) || defined(LUA_LIB) /* { */
275#define LUA_API __declspec(dllexport)
276#else /* }{ */
277#define LUA_API __declspec(dllimport)
278#endif /* } */
279
280#else /* }{ */
281
282#define LUA_API extern
283
284#endif /* } */
285
286
287/*
288** More often than not the libs go together with the core.
289*/
290#define LUALIB_API LUA_API
291#define LUAMOD_API LUA_API
292
293
294/*
295@@ LUAI_FUNC is a mark for all extern functions that are not to be
296** exported to outside modules.
297@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables,
298** none of which to be exported to outside modules (LUAI_DDEF for
299** definitions and LUAI_DDEC for declarations).
300** CHANGE them if you need to mark them in some special way. Elf/gcc
301** (versions 3.2 and later) mark them as "hidden" to optimize access
302** when Lua is compiled as a shared library. Not all elf targets support
303** this attribute. Unfortunately, gcc does not offer a way to check
304** whether the target offers that support, and those without support
305** give a warning about it. To avoid these warnings, change to the
306** default definition.
307*/
308#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
309 defined(__ELF__) /* { */
310#define LUAI_FUNC __attribute__((visibility("internal"))) extern
311#else /* }{ */
312#define LUAI_FUNC extern
313#endif /* } */
314
315#define LUAI_DDEC(dec) LUAI_FUNC dec
316#define LUAI_DDEF /* empty */
317
318/* }================================================================== */
319
320
321/*
322** {==================================================================
323** Compatibility with previous versions
324** ===================================================================
325*/
326
327/*
328@@ LUA_COMPAT_5_3 controls other macros for compatibility with Lua 5.3.
329** You can define it to get all options, or change specific options
330** to fit your specific needs.
331*/
332#if defined(LUA_COMPAT_5_3) /* { */
333
334/*
335@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
336** functions in the mathematical library.
337** (These functions were already officially removed in 5.3;
338** nevertheless they are still available here.)
339*/
340#define LUA_COMPAT_MATHLIB
341
342/*
343@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for
344** manipulating other integer types (lua_pushunsigned, lua_tounsigned,
345** luaL_checkint, luaL_checklong, etc.)
346** (These macros were also officially removed in 5.3, but they are still
347** available here.)
348*/
349#define LUA_COMPAT_APIINTCASTS
350
351
352/*
353@@ LUA_COMPAT_LT_LE controls the emulation of the '__le' metamethod
354** using '__lt'.
355*/
356#define LUA_COMPAT_LT_LE
357
358
359/*
360@@ The following macros supply trivial compatibility for some
361** changes in the API. The macros themselves document how to
362** change your code to avoid using them.
363** (Once more, these macros were officially removed in 5.3, but they are
364** still available here.)
365*/
366#define lua_strlen(L,i) lua_rawlen(L, (i))
367
368#define lua_objlen(L,i) lua_rawlen(L, (i))
369
370#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ)
371#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT)
372
373#endif /* } */
374
375/* }================================================================== */
376
377
378
379/*
380** {==================================================================
381** Configuration for Numbers (low-level part).
382** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_*
383** satisfy your needs.
384** ===================================================================
385*/
386
387/*
388@@ LUAI_UACNUMBER is the result of a 'default argument promotion'
389@@ over a floating number.
390@@ l_floatatt(x) corrects float attribute 'x' to the proper float type
391** by prefixing it with one of FLT/DBL/LDBL.
392@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
393@@ LUA_NUMBER_FMT is the format for writing floats.
394@@ lua_number2str converts a float to a string.
395@@ l_mathop allows the addition of an 'l' or 'f' to all math operations.
396@@ l_floor takes the floor of a float.
397@@ lua_str2number converts a decimal numeral to a number.
398*/
399
400
401/* The following definitions are good for most cases here */
402
403#define l_floor(x) (l_mathop(floor)(x))
404
405#define lua_number2str(s,sz,n) \
406 l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n))
407
408/*
409@@ lua_numbertointeger converts a float number with an integral value
410** to an integer, or returns 0 if float is not within the range of
411** a lua_Integer. (The range comparisons are tricky because of
412** rounding. The tests here assume a two-complement representation,
413** where MININTEGER always has an exact representation as a float;
414** MAXINTEGER may not have one, and therefore its conversion to float
415** may have an ill-defined value.)
416*/
417#define lua_numbertointeger(n,p) \
418 ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
419 (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
420 (*(p) = (LUA_INTEGER)(n), 1))
421
422
423/* now the variable definitions */
424
425#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */
426
427#define LUA_NUMBER float
428
429#define l_floatatt(n) (FLT_##n)
430
431#define LUAI_UACNUMBER double
432
433#define LUA_NUMBER_FRMLEN ""
434#define LUA_NUMBER_FMT "%.7g"
435
436#define l_mathop(op) op##f
437
438#define lua_str2number(s,p) strtof((s), (p))
439
440
441#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */
442
443#define LUA_NUMBER long double
444
445#define l_floatatt(n) (LDBL_##n)
446
447#define LUAI_UACNUMBER long double
448
449#define LUA_NUMBER_FRMLEN "L"
450#define LUA_NUMBER_FMT "%.19Lg"
451
452#define l_mathop(op) op##l
453
454#define lua_str2number(s,p) strtold((s), (p))
455
456#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */
457
458#define LUA_NUMBER double
459
460#define l_floatatt(n) (DBL_##n)
461
462#define LUAI_UACNUMBER double
463
464#define LUA_NUMBER_FRMLEN ""
465#define LUA_NUMBER_FMT "%.14g"
466
467#define l_mathop(op) op
468
469#define lua_str2number(s,p) strtod((s), (p))
470
471#else /* }{ */
472
473#error "numeric float type not defined"
474
475#endif /* } */
476
477
478
479/*
480@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
481@@ LUAI_UACINT is the result of a 'default argument promotion'
482@@ over a LUA_INTEGER.
483@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
484@@ LUA_INTEGER_FMT is the format for writing integers.
485@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
486@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
487@@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED.
488@@ lua_integer2str converts an integer to a string.
489*/
490
491
492/* The following definitions are good for most cases here */
493
494#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d"
495
496#define LUAI_UACINT LUA_INTEGER
497
498#define lua_integer2str(s,sz,n) \
499 l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n))
500
501/*
502** use LUAI_UACINT here to avoid problems with promotions (which
503** can turn a comparison between unsigneds into a signed comparison)
504*/
505#define LUA_UNSIGNED unsigned LUAI_UACINT
506
507
508/* now the variable definitions */
509
510#if LUA_INT_TYPE == LUA_INT_INT /* { int */
511
512#define LUA_INTEGER int
513#define LUA_INTEGER_FRMLEN ""
514
515#define LUA_MAXINTEGER INT_MAX
516#define LUA_MININTEGER INT_MIN
517
518#define LUA_MAXUNSIGNED UINT_MAX
519
520#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */
521
522#define LUA_INTEGER long
523#define LUA_INTEGER_FRMLEN "l"
524
525#define LUA_MAXINTEGER LONG_MAX
526#define LUA_MININTEGER LONG_MIN
527
528#define LUA_MAXUNSIGNED ULONG_MAX
529
530#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */
531
532/* use presence of macro LLONG_MAX as proxy for C99 compliance */
533#if defined(LLONG_MAX) /* { */
534/* use ISO C99 stuff */
535
536#define LUA_INTEGER long long
537#define LUA_INTEGER_FRMLEN "ll"
538
539#define LUA_MAXINTEGER LLONG_MAX
540#define LUA_MININTEGER LLONG_MIN
541
542#define LUA_MAXUNSIGNED ULLONG_MAX
543
544#elif defined(LUA_USE_WINDOWS) /* }{ */
545/* in Windows, can use specific Windows types */
546
547#define LUA_INTEGER __int64
548#define LUA_INTEGER_FRMLEN "I64"
549
550#define LUA_MAXINTEGER _I64_MAX
551#define LUA_MININTEGER _I64_MIN
552
553#define LUA_MAXUNSIGNED _UI64_MAX
554
555#else /* }{ */
556
557#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \
558 or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)"
559
560#endif /* } */
561
562#else /* }{ */
563
564#error "numeric integer type not defined"
565
566#endif /* } */
567
568/* }================================================================== */
569
570
571/*
572** {==================================================================
573** Dependencies with C99 and other C details
574** ===================================================================
575*/
576
577/*
578@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
579** (All uses in Lua have only one format item.)
580*/
581#if !defined(LUA_USE_C89)
582#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i)
583#else
584#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i))
585#endif
586
587
588/*
589@@ lua_strx2number converts a hexadecimal numeral to a number.
590** In C99, 'strtod' does that conversion. Otherwise, you can
591** leave 'lua_strx2number' undefined and Lua will provide its own
592** implementation.
593*/
594#if !defined(LUA_USE_C89)
595#define lua_strx2number(s,p) lua_str2number(s,p)
596#endif
597
598
599/*
600@@ lua_pointer2str converts a pointer to a readable string in a
601** non-specified way.
602*/
603#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p)
604
605
606/*
607@@ lua_number2strx converts a float to a hexadecimal numeral.
608** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
609** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
610** provide its own implementation.
611*/
612#if !defined(LUA_USE_C89)
613#define lua_number2strx(L,b,sz,f,n) \
614 ((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n)))
615#endif
616
617
618/*
619** 'strtof' and 'opf' variants for math functions are not valid in
620** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the
621** availability of these variants. ('math.h' is already included in
622** all files that use these macros.)
623*/
624#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF))
625#undef l_mathop /* variants not available */
626#undef lua_str2number
627#define l_mathop(op) (lua_Number)op /* no variant */
628#define lua_str2number(s,p) ((lua_Number)strtod((s), (p)))
629#endif
630
631
632/*
633@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation
634** functions. It must be a numerical type; Lua will use 'intptr_t' if
635** available, otherwise it will use 'ptrdiff_t' (the nearest thing to
636** 'intptr_t' in C89)
637*/
638#define LUA_KCONTEXT ptrdiff_t
639
640#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
641 __STDC_VERSION__ >= 199901L
642#include <stdint.h>
643#if defined(INTPTR_MAX) /* even in C99 this type is optional */
644#undef LUA_KCONTEXT
645#define LUA_KCONTEXT intptr_t
646#endif
647#endif
648
649
650/*
651@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point).
652** Change that if you do not want to use C locales. (Code using this
653** macro must include the header 'locale.h'.)
654*/
655#if !defined(lua_getlocaledecpoint)
656#define lua_getlocaledecpoint() (localeconv()->decimal_point[0])
657#endif
658
659
660/*
661** macros to improve jump prediction, used mostly for error handling
662** and debug facilities. (Some macros in the Lua API use these macros.
663** Define LUA_NOBUILTIN if you do not want '__builtin_expect' in your
664** code.)
665*/
666#if !defined(luai_likely)
667
668#if defined(__GNUC__) && !defined(LUA_NOBUILTIN)
669#define luai_likely(x) (__builtin_expect(((x) != 0), 1))
670#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0))
671#else
672#define luai_likely(x) (x)
673#define luai_unlikely(x) (x)
674#endif
675
676#endif
677
678
679#if defined(LUA_CORE) || defined(LUA_LIB)
680/* shorter names for Lua's own use */
681#define l_likely(x) luai_likely(x)
682#define l_unlikely(x) luai_unlikely(x)
683#endif
684
685
686
687/* }================================================================== */
688
689
690/*
691** {==================================================================
692** Language Variations
693** =====================================================================
694*/
695
696/*
697@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some
698** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from
699** numbers to strings. Define LUA_NOCVTS2N to turn off automatic
700** coercion from strings to numbers.
701*/
702/* #define LUA_NOCVTN2S */
703/* #define LUA_NOCVTS2N */
704
705
706/*
707@@ LUA_USE_APICHECK turns on several consistency checks on the C API.
708** Define it as a help when debugging C code.
709*/
710#if defined(LUA_USE_APICHECK)
711#include <assert.h>
712#define luai_apicheck(l,e) assert(e)
713#endif
714
715/* }================================================================== */
716
717
718/*
719** {==================================================================
720** Macros that affect the API and must be stable (that is, must be the
721** same when you compile Lua and when you compile code that links to
722** Lua).
723** =====================================================================
724*/
725
726/*
727@@ LUAI_MAXSTACK limits the size of the Lua stack.
728** CHANGE it if you need a different limit. This limit is arbitrary;
729** its only purpose is to stop Lua from consuming unlimited stack
730** space (and to reserve some numbers for pseudo-indices).
731** (It must fit into max(size_t)/32.)
732*/
733#if LUAI_IS32INT
734#define LUAI_MAXSTACK 1000000
735#else
736#define LUAI_MAXSTACK 15000
737#endif
738
739
740/*
741@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
742** a Lua state with very fast access.
743** CHANGE it if you need a different size.
744*/
745#define LUA_EXTRASPACE (sizeof(void *))
746
747
748/*
749@@ LUA_IDSIZE gives the maximum size for the description of the source
750@@ of a function in debug information.
751** CHANGE it if you want a different size.
752*/
753#define LUA_IDSIZE 60
754
755
756/*
757@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
758*/
759#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number)))
760
761
762/*
763@@ LUAI_MAXALIGN defines fields that, when used in a union, ensure
764** maximum alignment for the other items in that union.
765*/
766#define LUAI_MAXALIGN lua_Number n; double u; void *s; lua_Integer i; long l
767
768/* }================================================================== */
769
770
771
772
773
774/* =================================================================== */
775
776/*
777** Local configuration. You can use this space to add your redefinitions
778** without modifying the main part of the file.
779*/
780
781
782
783
784
785#endif
786
787