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/* This defines DEB_HOST_MULTIARCH */
221#include "lua5.4-deb-multiarch.h"
222
223#define LUA_ROOT "/usr/local/"
224#define LUA_ROOT2 "/usr/"
225#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/"
226#define LUA_LDIR2 LUA_ROOT2 "share/lua/" LUA_VDIR "/"
227#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/"
228#define LUA_CDIR2 LUA_ROOT2 "lib/" DEB_HOST_MULTIARCH "/lua/" LUA_VDIR "/"
229#define LUA_CDIR3 LUA_ROOT2 "lib/lua/" LUA_VDIR "/"
230
231#if !defined(LUA_PATH_DEFAULT)
232#define LUA_PATH_DEFAULT \
233 LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \
234 LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \
235 LUA_LDIR2"?.lua;" LUA_LDIR2"?/init.lua;" \
236 "./?.lua;" "./?/init.lua"
237#endif
238
239#if !defined(LUA_CPATH_DEFAULT)
240#define LUA_CPATH_DEFAULT \
241 LUA_CDIR"?.so;" LUA_CDIR2"?.so;" LUA_CDIR3"?.so;" LUA_CDIR"loadall.so;" "./?.so"
242#endif
243
244#endif /* } */
245
246
247/*
248@@ LUA_DIRSEP is the directory separator (for submodules).
249** CHANGE it if your machine does not use "/" as the directory separator
250** and is not Windows. (On Windows Lua automatically uses "\".)
251*/
252#if !defined(LUA_DIRSEP)
253
254#if defined(_WIN32)
255#define LUA_DIRSEP "\\"
256#else
257#define LUA_DIRSEP "/"
258#endif
259
260#endif
261
262/* }================================================================== */
263
264
265/*
266** {==================================================================
267** Marks for exported symbols in the C code
268** ===================================================================
269*/
270
271/*
272@@ LUA_API is a mark for all core API functions.
273@@ LUALIB_API is a mark for all auxiliary library functions.
274@@ LUAMOD_API is a mark for all standard library opening functions.
275** CHANGE them if you need to define those functions in some special way.
276** For instance, if you want to create one Windows DLL with the core and
277** the libraries, you may want to use the following definition (define
278** LUA_BUILD_AS_DLL to get it).
279*/
280#if defined(LUA_BUILD_AS_DLL) /* { */
281
282#if defined(LUA_CORE) || defined(LUA_LIB) /* { */
283#define LUA_API __declspec(dllexport)
284#else /* }{ */
285#define LUA_API __declspec(dllimport)
286#endif /* } */
287
288#else /* }{ */
289
290#ifdef __cplusplus
291#define LUA_API extern "C"
292#else
293#define LUA_API extern
294#endif
295
296#endif /* } */
297
298
299/*
300** More often than not the libs go together with the core.
301*/
302#define LUALIB_API LUA_API
303#define LUAMOD_API LUA_API
304
305
306/*
307@@ LUAI_FUNC is a mark for all extern functions that are not to be
308** exported to outside modules.
309@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables,
310** none of which to be exported to outside modules (LUAI_DDEF for
311** definitions and LUAI_DDEC for declarations).
312** CHANGE them if you need to mark them in some special way. Elf/gcc
313** (versions 3.2 and later) mark them as "hidden" to optimize access
314** when Lua is compiled as a shared library. Not all elf targets support
315** this attribute. Unfortunately, gcc does not offer a way to check
316** whether the target offers that support, and those without support
317** give a warning about it. To avoid these warnings, change to the
318** default definition.
319*/
320#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
321 defined(__ELF__) /* { */
322#define LUAI_FUNC __attribute__((visibility("internal"))) extern
323#else /* }{ */
324#define LUAI_FUNC extern
325#endif /* } */
326
327#define LUAI_DDEC(dec) LUAI_FUNC dec
328#define LUAI_DDEF /* empty */
329
330/* }================================================================== */
331
332
333/*
334** {==================================================================
335** Compatibility with previous versions
336** ===================================================================
337*/
338
339/*
340@@ LUA_COMPAT_5_3 controls other macros for compatibility with Lua 5.3.
341** You can define it to get all options, or change specific options
342** to fit your specific needs.
343*/
344#if defined(LUA_COMPAT_5_3) /* { */
345
346/*
347@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
348** functions in the mathematical library.
349** (These functions were already officially removed in 5.3;
350** nevertheless they are still available here.)
351*/
352#define LUA_COMPAT_MATHLIB
353
354/*
355@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for
356** manipulating other integer types (lua_pushunsigned, lua_tounsigned,
357** luaL_checkint, luaL_checklong, etc.)
358** (These macros were also officially removed in 5.3, but they are still
359** available here.)
360*/
361#define LUA_COMPAT_APIINTCASTS
362
363
364/*
365@@ LUA_COMPAT_LT_LE controls the emulation of the '__le' metamethod
366** using '__lt'.
367*/
368#define LUA_COMPAT_LT_LE
369
370
371/*
372@@ The following macros supply trivial compatibility for some
373** changes in the API. The macros themselves document how to
374** change your code to avoid using them.
375** (Once more, these macros were officially removed in 5.3, but they are
376** still available here.)
377*/
378#define lua_strlen(L,i) lua_rawlen(L, (i))
379
380#define lua_objlen(L,i) lua_rawlen(L, (i))
381
382#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ)
383#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT)
384
385#endif /* } */
386
387/* }================================================================== */
388
389
390
391/*
392** {==================================================================
393** Configuration for Numbers (low-level part).
394** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_*
395** satisfy your needs.
396** ===================================================================
397*/
398
399/*
400@@ LUAI_UACNUMBER is the result of a 'default argument promotion'
401@@ over a floating number.
402@@ l_floatatt(x) corrects float attribute 'x' to the proper float type
403** by prefixing it with one of FLT/DBL/LDBL.
404@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
405@@ LUA_NUMBER_FMT is the format for writing floats.
406@@ lua_number2str converts a float to a string.
407@@ l_mathop allows the addition of an 'l' or 'f' to all math operations.
408@@ l_floor takes the floor of a float.
409@@ lua_str2number converts a decimal numeral to a number.
410*/
411
412
413/* The following definitions are good for most cases here */
414
415#define l_floor(x) (l_mathop(floor)(x))
416
417#define lua_number2str(s,sz,n) \
418 l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n))
419
420/*
421@@ lua_numbertointeger converts a float number with an integral value
422** to an integer, or returns 0 if float is not within the range of
423** a lua_Integer. (The range comparisons are tricky because of
424** rounding. The tests here assume a two-complement representation,
425** where MININTEGER always has an exact representation as a float;
426** MAXINTEGER may not have one, and therefore its conversion to float
427** may have an ill-defined value.)
428*/
429#define lua_numbertointeger(n,p) \
430 ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
431 (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
432 (*(p) = (LUA_INTEGER)(n), 1))
433
434
435/* now the variable definitions */
436
437#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */
438
439#define LUA_NUMBER float
440
441#define l_floatatt(n) (FLT_##n)
442
443#define LUAI_UACNUMBER double
444
445#define LUA_NUMBER_FRMLEN ""
446#define LUA_NUMBER_FMT "%.7g"
447
448#define l_mathop(op) op##f
449
450#define lua_str2number(s,p) strtof((s), (p))
451
452
453#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */
454
455#define LUA_NUMBER long double
456
457#define l_floatatt(n) (LDBL_##n)
458
459#define LUAI_UACNUMBER long double
460
461#define LUA_NUMBER_FRMLEN "L"
462#define LUA_NUMBER_FMT "%.19Lg"
463
464#define l_mathop(op) op##l
465
466#define lua_str2number(s,p) strtold((s), (p))
467
468#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */
469
470#define LUA_NUMBER double
471
472#define l_floatatt(n) (DBL_##n)
473
474#define LUAI_UACNUMBER double
475
476#define LUA_NUMBER_FRMLEN ""
477#define LUA_NUMBER_FMT "%.14g"
478
479#define l_mathop(op) op
480
481#define lua_str2number(s,p) strtod((s), (p))
482
483#else /* }{ */
484
485#error "numeric float type not defined"
486
487#endif /* } */
488
489
490
491/*
492@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
493@@ LUAI_UACINT is the result of a 'default argument promotion'
494@@ over a LUA_INTEGER.
495@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
496@@ LUA_INTEGER_FMT is the format for writing integers.
497@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
498@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
499@@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED.
500@@ lua_integer2str converts an integer to a string.
501*/
502
503
504/* The following definitions are good for most cases here */
505
506#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d"
507
508#define LUAI_UACINT LUA_INTEGER
509
510#define lua_integer2str(s,sz,n) \
511 l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n))
512
513/*
514** use LUAI_UACINT here to avoid problems with promotions (which
515** can turn a comparison between unsigneds into a signed comparison)
516*/
517#define LUA_UNSIGNED unsigned LUAI_UACINT
518
519
520/* now the variable definitions */
521
522#if LUA_INT_TYPE == LUA_INT_INT /* { int */
523
524#define LUA_INTEGER int
525#define LUA_INTEGER_FRMLEN ""
526
527#define LUA_MAXINTEGER INT_MAX
528#define LUA_MININTEGER INT_MIN
529
530#define LUA_MAXUNSIGNED UINT_MAX
531
532#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */
533
534#define LUA_INTEGER long
535#define LUA_INTEGER_FRMLEN "l"
536
537#define LUA_MAXINTEGER LONG_MAX
538#define LUA_MININTEGER LONG_MIN
539
540#define LUA_MAXUNSIGNED ULONG_MAX
541
542#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */
543
544/* use presence of macro LLONG_MAX as proxy for C99 compliance */
545#if defined(LLONG_MAX) /* { */
546/* use ISO C99 stuff */
547
548#define LUA_INTEGER long long
549#define LUA_INTEGER_FRMLEN "ll"
550
551#define LUA_MAXINTEGER LLONG_MAX
552#define LUA_MININTEGER LLONG_MIN
553
554#define LUA_MAXUNSIGNED ULLONG_MAX
555
556#elif defined(LUA_USE_WINDOWS) /* }{ */
557/* in Windows, can use specific Windows types */
558
559#define LUA_INTEGER __int64
560#define LUA_INTEGER_FRMLEN "I64"
561
562#define LUA_MAXINTEGER _I64_MAX
563#define LUA_MININTEGER _I64_MIN
564
565#define LUA_MAXUNSIGNED _UI64_MAX
566
567#else /* }{ */
568
569#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \
570 or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)"
571
572#endif /* } */
573
574#else /* }{ */
575
576#error "numeric integer type not defined"
577
578#endif /* } */
579
580/* }================================================================== */
581
582
583/*
584** {==================================================================
585** Dependencies with C99 and other C details
586** ===================================================================
587*/
588
589/*
590@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
591** (All uses in Lua have only one format item.)
592*/
593#if !defined(LUA_USE_C89)
594#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i)
595#else
596#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i))
597#endif
598
599
600/*
601@@ lua_strx2number converts a hexadecimal numeral to a number.
602** In C99, 'strtod' does that conversion. Otherwise, you can
603** leave 'lua_strx2number' undefined and Lua will provide its own
604** implementation.
605*/
606#if !defined(LUA_USE_C89)
607#define lua_strx2number(s,p) lua_str2number(s,p)
608#endif
609
610
611/*
612@@ lua_pointer2str converts a pointer to a readable string in a
613** non-specified way.
614*/
615#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p)
616
617
618/*
619@@ lua_number2strx converts a float to a hexadecimal numeral.
620** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
621** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
622** provide its own implementation.
623*/
624#if !defined(LUA_USE_C89)
625#define lua_number2strx(L,b,sz,f,n) \
626 ((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n)))
627#endif
628
629
630/*
631** 'strtof' and 'opf' variants for math functions are not valid in
632** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the
633** availability of these variants. ('math.h' is already included in
634** all files that use these macros.)
635*/
636#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF))
637#undef l_mathop /* variants not available */
638#undef lua_str2number
639#define l_mathop(op) (lua_Number)op /* no variant */
640#define lua_str2number(s,p) ((lua_Number)strtod((s), (p)))
641#endif
642
643
644/*
645@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation
646** functions. It must be a numerical type; Lua will use 'intptr_t' if
647** available, otherwise it will use 'ptrdiff_t' (the nearest thing to
648** 'intptr_t' in C89)
649*/
650#define LUA_KCONTEXT ptrdiff_t
651
652#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
653 __STDC_VERSION__ >= 199901L
654#include <stdint.h>
655#if defined(INTPTR_MAX) /* even in C99 this type is optional */
656#undef LUA_KCONTEXT
657#define LUA_KCONTEXT intptr_t
658#endif
659#endif
660
661
662/*
663@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point).
664** Change that if you do not want to use C locales. (Code using this
665** macro must include the header 'locale.h'.)
666*/
667#if !defined(lua_getlocaledecpoint)
668#define lua_getlocaledecpoint() (localeconv()->decimal_point[0])
669#endif
670
671
672/*
673** macros to improve jump prediction, used mostly for error handling
674** and debug facilities. (Some macros in the Lua API use these macros.
675** Define LUA_NOBUILTIN if you do not want '__builtin_expect' in your
676** code.)
677*/
678#if !defined(luai_likely)
679
680#if defined(__GNUC__) && !defined(LUA_NOBUILTIN)
681#define luai_likely(x) (__builtin_expect(((x) != 0), 1))
682#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0))
683#else
684#define luai_likely(x) (x)
685#define luai_unlikely(x) (x)
686#endif
687
688#endif
689
690
691#if defined(LUA_CORE) || defined(LUA_LIB)
692/* shorter names for Lua's own use */
693#define l_likely(x) luai_likely(x)
694#define l_unlikely(x) luai_unlikely(x)
695#endif
696
697
698
699/* }================================================================== */
700
701
702/*
703** {==================================================================
704** Language Variations
705** =====================================================================
706*/
707
708/*
709@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some
710** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from
711** numbers to strings. Define LUA_NOCVTS2N to turn off automatic
712** coercion from strings to numbers.
713*/
714/* #define LUA_NOCVTN2S */
715/* #define LUA_NOCVTS2N */
716
717
718/*
719@@ LUA_USE_APICHECK turns on several consistency checks on the C API.
720** Define it as a help when debugging C code.
721*/
722#if defined(LUA_USE_APICHECK)
723#include <assert.h>
724#define luai_apicheck(l,e) assert(e)
725#endif
726
727/* }================================================================== */
728
729
730/*
731** {==================================================================
732** Macros that affect the API and must be stable (that is, must be the
733** same when you compile Lua and when you compile code that links to
734** Lua).
735** =====================================================================
736*/
737
738/*
739@@ LUAI_MAXSTACK limits the size of the Lua stack.
740** CHANGE it if you need a different limit. This limit is arbitrary;
741** its only purpose is to stop Lua from consuming unlimited stack
742** space (and to reserve some numbers for pseudo-indices).
743** (It must fit into max(size_t)/32.)
744*/
745#if LUAI_IS32INT
746#define LUAI_MAXSTACK 1000000
747#else
748#define LUAI_MAXSTACK 15000
749#endif
750
751
752/*
753@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
754** a Lua state with very fast access.
755** CHANGE it if you need a different size.
756*/
757#define LUA_EXTRASPACE (sizeof(void *))
758
759
760/*
761@@ LUA_IDSIZE gives the maximum size for the description of the source
762@@ of a function in debug information.
763** CHANGE it if you want a different size.
764*/
765#define LUA_IDSIZE 60
766
767
768/*
769@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
770*/
771#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number)))
772
773
774/*
775@@ LUAI_MAXALIGN defines fields that, when used in a union, ensure
776** maximum alignment for the other items in that union.
777*/
778#define LUAI_MAXALIGN lua_Number n; double u; void *s; lua_Integer i; long l
779
780/* }================================================================== */
781
782
783
784
785
786/* =================================================================== */
787
788/*
789** Local configuration. You can use this space to add your redefinitions
790** without modifying the main part of the file.
791*/
792
793
794
795
796
797#endif
798
799