diff options
Diffstat (limited to '')
-rw-r--r-- | libraries/LuaJIT-1.1.7/src/luaconf.h | 786 |
1 files changed, 0 insertions, 786 deletions
diff --git a/libraries/LuaJIT-1.1.7/src/luaconf.h b/libraries/LuaJIT-1.1.7/src/luaconf.h deleted file mode 100644 index 35a6bd1..0000000 --- a/libraries/LuaJIT-1.1.7/src/luaconf.h +++ /dev/null | |||
@@ -1,786 +0,0 @@ | |||
1 | /* | ||
2 | ** $Id: luaconf.h,v 1.82.1.7 2008/02/11 16:25:08 roberto Exp $ | ||
3 | ** Configuration file for Lua | ||
4 | ** See Copyright Notice in lua.h | ||
5 | */ | ||
6 | |||
7 | |||
8 | #ifndef lconfig_h | ||
9 | #define lconfig_h | ||
10 | |||
11 | #include <limits.h> | ||
12 | #include <stddef.h> | ||
13 | |||
14 | |||
15 | /* | ||
16 | ** ================================================================== | ||
17 | ** Search for "@@" to find all configurable definitions. | ||
18 | ** =================================================================== | ||
19 | */ | ||
20 | |||
21 | |||
22 | /* | ||
23 | @@ LUA_ANSI controls the use of non-ansi features. | ||
24 | ** CHANGE it (define it) if you want Lua to avoid the use of any | ||
25 | ** non-ansi feature or library. | ||
26 | */ | ||
27 | #if defined(__STRICT_ANSI__) | ||
28 | #define LUA_ANSI | ||
29 | #endif | ||
30 | |||
31 | |||
32 | #if !defined(LUA_ANSI) && defined(_WIN32) | ||
33 | #define LUA_WIN | ||
34 | #endif | ||
35 | |||
36 | #if defined(LUA_USE_LINUX) | ||
37 | #define LUA_USE_POSIX | ||
38 | #define LUA_USE_DLOPEN /* needs an extra library: -ldl */ | ||
39 | /* #define LUA_USE_READLINE */ /* needs some extra libraries */ | ||
40 | #endif | ||
41 | |||
42 | #if defined(LUA_USE_MACOSX) | ||
43 | #define LUA_USE_POSIX | ||
44 | #define LUA_DL_DYLD /* does not need extra library */ | ||
45 | #endif | ||
46 | |||
47 | |||
48 | |||
49 | /* | ||
50 | @@ LUA_USE_POSIX includes all functionallity listed as X/Open System | ||
51 | @* Interfaces Extension (XSI). | ||
52 | ** CHANGE it (define it) if your system is XSI compatible. | ||
53 | */ | ||
54 | #if defined(LUA_USE_POSIX) | ||
55 | #define LUA_USE_MKSTEMP | ||
56 | #define LUA_USE_ISATTY | ||
57 | #define LUA_USE_POPEN | ||
58 | #define LUA_USE_ULONGJMP | ||
59 | #endif | ||
60 | |||
61 | |||
62 | /* | ||
63 | @@ LUA_PATH and LUA_CPATH are the names of the environment variables that | ||
64 | @* Lua check to set its paths. | ||
65 | @@ LUA_INIT is the name of the environment variable that Lua | ||
66 | @* checks for initialization code. | ||
67 | ** CHANGE them if you want different names. | ||
68 | */ | ||
69 | #define LUA_PATH "LUA_PATH" | ||
70 | #define LUA_CPATH "LUA_CPATH" | ||
71 | #define LUA_INIT "LUA_INIT" | ||
72 | |||
73 | |||
74 | /* | ||
75 | @@ LUA_PATH_DEFAULT is the default path that Lua uses to look for | ||
76 | @* Lua libraries. | ||
77 | @@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for | ||
78 | @* C libraries. | ||
79 | ** CHANGE them if your machine has a non-conventional directory | ||
80 | ** hierarchy or if you want to install your libraries in | ||
81 | ** non-conventional directories. | ||
82 | */ | ||
83 | #if defined(_WIN32) | ||
84 | /* | ||
85 | ** In Windows, any exclamation mark ('!') in the path is replaced by the | ||
86 | ** path of the directory of the executable file of the current process. | ||
87 | */ | ||
88 | #define LUA_LDIR "!\\lua\\" | ||
89 | #define LUA_CDIR "!\\" | ||
90 | #define LUA_PATH_DEFAULT \ | ||
91 | ".\\?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ | ||
92 | LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua" | ||
93 | #define LUA_CPATH_DEFAULT \ | ||
94 | ".\\?.dll;" LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll" | ||
95 | |||
96 | #else | ||
97 | #define LUA_ROOT "/usr/local/" | ||
98 | #define LUA_LDIR LUA_ROOT "share/lua/5.1/" | ||
99 | #define LUA_CDIR LUA_ROOT "lib/lua/5.1/" | ||
100 | #define LUA_PATH_DEFAULT \ | ||
101 | "./?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ | ||
102 | LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua" | ||
103 | #define LUA_CPATH_DEFAULT \ | ||
104 | "./?.so;" LUA_CDIR"?.so;" LUA_CDIR"loadall.so" | ||
105 | #endif | ||
106 | |||
107 | |||
108 | /* | ||
109 | @@ LUA_DIRSEP is the directory separator (for submodules). | ||
110 | ** CHANGE it if your machine does not use "/" as the directory separator | ||
111 | ** and is not Windows. (On Windows Lua automatically uses "\".) | ||
112 | */ | ||
113 | #if defined(_WIN32) | ||
114 | #define LUA_DIRSEP "\\" | ||
115 | #else | ||
116 | #define LUA_DIRSEP "/" | ||
117 | #endif | ||
118 | |||
119 | |||
120 | /* | ||
121 | @@ LUA_PATHSEP is the character that separates templates in a path. | ||
122 | @@ LUA_PATH_MARK is the string that marks the substitution points in a | ||
123 | @* template. | ||
124 | @@ LUA_EXECDIR in a Windows path is replaced by the executable's | ||
125 | @* directory. | ||
126 | @@ LUA_IGMARK is a mark to ignore all before it when bulding the | ||
127 | @* luaopen_ function name. | ||
128 | ** CHANGE them if for some reason your system cannot use those | ||
129 | ** characters. (E.g., if one of those characters is a common character | ||
130 | ** in file/directory names.) Probably you do not need to change them. | ||
131 | */ | ||
132 | #define LUA_PATHSEP ";" | ||
133 | #define LUA_PATH_MARK "?" | ||
134 | #define LUA_EXECDIR "!" | ||
135 | #define LUA_IGMARK "-" | ||
136 | |||
137 | |||
138 | /* | ||
139 | @@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger. | ||
140 | ** CHANGE that if ptrdiff_t is not adequate on your machine. (On most | ||
141 | ** machines, ptrdiff_t gives a good choice between int or long.) | ||
142 | */ | ||
143 | #define LUA_INTEGER ptrdiff_t | ||
144 | |||
145 | |||
146 | /* | ||
147 | @@ LUA_API is a mark for all core API functions. | ||
148 | @@ LUALIB_API is a mark for all standard library functions. | ||
149 | ** CHANGE them if you need to define those functions in some special way. | ||
150 | ** For instance, if you want to create one Windows DLL with the core and | ||
151 | ** the libraries, you may want to use the following definition (define | ||
152 | ** LUA_BUILD_AS_DLL to get it). | ||
153 | */ | ||
154 | #if defined(LUA_BUILD_AS_DLL) | ||
155 | |||
156 | #if defined(LUA_CORE) || defined(LUA_LIB) | ||
157 | #define LUA_API __declspec(dllexport) | ||
158 | #else | ||
159 | #define LUA_API __declspec(dllimport) | ||
160 | #endif | ||
161 | |||
162 | #else | ||
163 | |||
164 | #define LUA_API extern | ||
165 | |||
166 | #endif | ||
167 | |||
168 | /* more often than not the libs go together with the core */ | ||
169 | #define LUALIB_API LUA_API | ||
170 | |||
171 | |||
172 | /* | ||
173 | @@ LUAI_FUNC is a mark for all extern functions that are not to be | ||
174 | @* exported to outside modules. | ||
175 | @@ LUAI_DATA is a mark for all extern (const) variables that are not to | ||
176 | @* be exported to outside modules. | ||
177 | ** CHANGE them if you need to mark them in some special way. Elf/gcc | ||
178 | ** (versions 3.2 and later) mark them as "hidden" to optimize access | ||
179 | ** when Lua is compiled as a shared library. | ||
180 | */ | ||
181 | #if defined(luaall_c) | ||
182 | #define LUAI_FUNC static | ||
183 | #define LUAI_DATA /* empty */ | ||
184 | |||
185 | #elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ | ||
186 | defined(__ELF__) | ||
187 | #define LUAI_FUNC __attribute__((visibility("hidden"))) extern | ||
188 | #define LUAI_DATA LUAI_FUNC | ||
189 | |||
190 | #else | ||
191 | #define LUAI_FUNC extern | ||
192 | #define LUAI_DATA extern | ||
193 | #endif | ||
194 | |||
195 | |||
196 | |||
197 | /* | ||
198 | @@ LUA_QL describes how error messages quote program elements. | ||
199 | ** CHANGE it if you want a different appearance. | ||
200 | */ | ||
201 | #define LUA_QL(x) "'" x "'" | ||
202 | #define LUA_QS LUA_QL("%s") | ||
203 | |||
204 | |||
205 | /* | ||
206 | @@ LUA_IDSIZE gives the maximum size for the description of the source | ||
207 | @* of a function in debug information. | ||
208 | ** CHANGE it if you want a different size. | ||
209 | */ | ||
210 | #define LUA_IDSIZE 60 | ||
211 | |||
212 | |||
213 | /* | ||
214 | ** {================================================================== | ||
215 | ** Stand-alone configuration | ||
216 | ** =================================================================== | ||
217 | */ | ||
218 | |||
219 | #if defined(lua_c) || defined(luaall_c) | ||
220 | |||
221 | /* | ||
222 | @@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that | ||
223 | @* is, whether we're running lua interactively). | ||
224 | ** CHANGE it if you have a better definition for non-POSIX/non-Windows | ||
225 | ** systems. | ||
226 | */ | ||
227 | #if defined(LUA_USE_ISATTY) | ||
228 | #include <unistd.h> | ||
229 | #define lua_stdin_is_tty() isatty(0) | ||
230 | #elif defined(LUA_WIN) | ||
231 | #include <io.h> | ||
232 | #include <stdio.h> | ||
233 | #define lua_stdin_is_tty() _isatty(_fileno(stdin)) | ||
234 | #else | ||
235 | #define lua_stdin_is_tty() 1 /* assume stdin is a tty */ | ||
236 | #endif | ||
237 | |||
238 | |||
239 | /* | ||
240 | @@ LUA_PROMPT is the default prompt used by stand-alone Lua. | ||
241 | @@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua. | ||
242 | ** CHANGE them if you want different prompts. (You can also change the | ||
243 | ** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.) | ||
244 | */ | ||
245 | #define LUA_PROMPT "> " | ||
246 | #define LUA_PROMPT2 ">> " | ||
247 | |||
248 | |||
249 | /* | ||
250 | @@ LUA_PROGNAME is the default name for the stand-alone Lua program. | ||
251 | ** CHANGE it if your stand-alone interpreter has a different name and | ||
252 | ** your system is not able to detect that name automatically. | ||
253 | */ | ||
254 | #define LUA_PROGNAME "luajit" | ||
255 | |||
256 | |||
257 | /* | ||
258 | @@ LUA_MAXINPUT is the maximum length for an input line in the | ||
259 | @* stand-alone interpreter. | ||
260 | ** CHANGE it if you need longer lines. | ||
261 | */ | ||
262 | #define LUA_MAXINPUT 512 | ||
263 | |||
264 | |||
265 | /* | ||
266 | @@ lua_readline defines how to show a prompt and then read a line from | ||
267 | @* the standard input. | ||
268 | @@ lua_saveline defines how to "save" a read line in a "history". | ||
269 | @@ lua_freeline defines how to free a line read by lua_readline. | ||
270 | ** CHANGE them if you want to improve this functionality (e.g., by using | ||
271 | ** GNU readline and history facilities). | ||
272 | */ | ||
273 | #if defined(LUA_USE_READLINE) | ||
274 | #include <stdio.h> | ||
275 | #include <readline/readline.h> | ||
276 | #include <readline/history.h> | ||
277 | #define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL) | ||
278 | #define lua_saveline(L,idx) \ | ||
279 | if (lua_strlen(L,idx) > 0) /* non-empty line? */ \ | ||
280 | add_history(lua_tostring(L, idx)); /* add it to history */ | ||
281 | #define lua_freeline(L,b) ((void)L, free(b)) | ||
282 | #else | ||
283 | #define lua_readline(L,b,p) \ | ||
284 | ((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \ | ||
285 | fgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */ | ||
286 | #define lua_saveline(L,idx) { (void)L; (void)idx; } | ||
287 | #define lua_freeline(L,b) { (void)L; (void)b; } | ||
288 | #endif | ||
289 | |||
290 | #endif | ||
291 | |||
292 | /* }================================================================== */ | ||
293 | |||
294 | |||
295 | /* | ||
296 | @@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles | ||
297 | @* as a percentage. | ||
298 | ** CHANGE it if you want the GC to run faster or slower (higher values | ||
299 | ** mean larger pauses which mean slower collection.) You can also change | ||
300 | ** this value dynamically. | ||
301 | */ | ||
302 | #define LUAI_GCPAUSE 200 /* 200% (wait memory to double before next GC) */ | ||
303 | |||
304 | |||
305 | /* | ||
306 | @@ LUAI_GCMUL defines the default speed of garbage collection relative to | ||
307 | @* memory allocation as a percentage. | ||
308 | ** CHANGE it if you want to change the granularity of the garbage | ||
309 | ** collection. (Higher values mean coarser collections. 0 represents | ||
310 | ** infinity, where each step performs a full collection.) You can also | ||
311 | ** change this value dynamically. | ||
312 | */ | ||
313 | #define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */ | ||
314 | |||
315 | |||
316 | |||
317 | /* | ||
318 | @@ LUA_COMPAT_GETN controls compatibility with old getn behavior. | ||
319 | ** CHANGE it (define it) if you want exact compatibility with the | ||
320 | ** behavior of setn/getn in Lua 5.0. | ||
321 | ** | ||
322 | ** Note: this is not supported by LuaJIT. Leave it undefined. | ||
323 | */ | ||
324 | #undef LUA_COMPAT_GETN | ||
325 | |||
326 | /* | ||
327 | @@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib. | ||
328 | ** CHANGE it to undefined as soon as you do not need a global 'loadlib' | ||
329 | ** function (the function is still available as 'package.loadlib'). | ||
330 | */ | ||
331 | #undef LUA_COMPAT_LOADLIB | ||
332 | |||
333 | /* | ||
334 | @@ LUA_COMPAT_VARARG controls compatibility with old vararg feature. | ||
335 | ** CHANGE it to undefined as soon as your programs use only '...' to | ||
336 | ** access vararg parameters (instead of the old 'arg' table). | ||
337 | ** | ||
338 | ** Note: this has a slightly negative performance impact with LuaJIT | ||
339 | ** for all vararg functions. Leave it off if possible and upgrade your | ||
340 | ** code (replace unpack(arg) with ... and/or add local arg = {...}). | ||
341 | */ | ||
342 | #undef LUA_COMPAT_VARARG | ||
343 | |||
344 | /* | ||
345 | @@ LUA_COMPAT_MOD controls compatibility with old math.mod function. | ||
346 | ** CHANGE it to undefined as soon as your programs use 'math.fmod' or | ||
347 | ** the new '%' operator instead of 'math.mod'. | ||
348 | */ | ||
349 | #define LUA_COMPAT_MOD | ||
350 | |||
351 | /* | ||
352 | @@ LUA_COMPAT_LSTR controls compatibility with old long string nesting | ||
353 | @* facility. | ||
354 | ** CHANGE it to 2 if you want the old behaviour, or undefine it to turn | ||
355 | ** off the advisory error when nesting [[...]]. | ||
356 | */ | ||
357 | #define LUA_COMPAT_LSTR 1 | ||
358 | |||
359 | /* | ||
360 | @@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name. | ||
361 | ** CHANGE it to undefined as soon as you rename 'string.gfind' to | ||
362 | ** 'string.gmatch'. | ||
363 | */ | ||
364 | #define LUA_COMPAT_GFIND | ||
365 | |||
366 | /* | ||
367 | @@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib' | ||
368 | @* behavior. | ||
369 | ** CHANGE it to undefined as soon as you replace to 'luaL_register' | ||
370 | ** your uses of 'luaL_openlib' | ||
371 | */ | ||
372 | #define LUA_COMPAT_OPENLIB | ||
373 | |||
374 | |||
375 | |||
376 | /* | ||
377 | @@ luai_apicheck is the assert macro used by the Lua-C API. | ||
378 | ** CHANGE luai_apicheck if you want Lua to perform some checks in the | ||
379 | ** parameters it gets from API calls. This may slow down the interpreter | ||
380 | ** a bit, but may be quite useful when debugging C code that interfaces | ||
381 | ** with Lua. A useful redefinition is to use assert.h. | ||
382 | */ | ||
383 | #if defined(LUA_USE_APICHECK) | ||
384 | #include <assert.h> | ||
385 | #define luai_apicheck(L,o) { (void)L; assert(o); } | ||
386 | #else | ||
387 | #define luai_apicheck(L,o) { (void)L; } | ||
388 | #endif | ||
389 | |||
390 | |||
391 | /* | ||
392 | @@ LUAI_BITSINT defines the number of bits in an int. | ||
393 | ** CHANGE here if Lua cannot automatically detect the number of bits of | ||
394 | ** your machine. Probably you do not need to change this. | ||
395 | */ | ||
396 | /* avoid overflows in comparison */ | ||
397 | #if INT_MAX-20 < 32760 | ||
398 | #define LUAI_BITSINT 16 | ||
399 | #elif INT_MAX > 2147483640L | ||
400 | /* int has at least 32 bits */ | ||
401 | #define LUAI_BITSINT 32 | ||
402 | #else | ||
403 | #error "you must define LUA_BITSINT with number of bits in an integer" | ||
404 | #endif | ||
405 | |||
406 | |||
407 | /* | ||
408 | @@ LUAI_UINT32 is an unsigned integer with at least 32 bits. | ||
409 | @@ LUAI_INT32 is an signed integer with at least 32 bits. | ||
410 | @@ LUAI_UMEM is an unsigned integer big enough to count the total | ||
411 | @* memory used by Lua. | ||
412 | @@ LUAI_MEM is a signed integer big enough to count the total memory | ||
413 | @* used by Lua. | ||
414 | ** CHANGE here if for some weird reason the default definitions are not | ||
415 | ** good enough for your machine. (The definitions in the 'else' | ||
416 | ** part always works, but may waste space on machines with 64-bit | ||
417 | ** longs.) Probably you do not need to change this. | ||
418 | */ | ||
419 | #if LUAI_BITSINT >= 32 | ||
420 | #define LUAI_UINT32 unsigned int | ||
421 | #define LUAI_INT32 int | ||
422 | #define LUAI_MAXINT32 INT_MAX | ||
423 | #define LUAI_UMEM size_t | ||
424 | #define LUAI_MEM ptrdiff_t | ||
425 | #else | ||
426 | /* 16-bit ints */ | ||
427 | #define LUAI_UINT32 unsigned long | ||
428 | #define LUAI_INT32 long | ||
429 | #define LUAI_MAXINT32 LONG_MAX | ||
430 | #define LUAI_UMEM unsigned long | ||
431 | #define LUAI_MEM long | ||
432 | #endif | ||
433 | |||
434 | |||
435 | /* | ||
436 | @@ LUAI_MAXCALLS limits the number of nested calls. | ||
437 | ** CHANGE it if you need really deep recursive calls. This limit is | ||
438 | ** arbitrary; its only purpose is to stop infinite recursion before | ||
439 | ** exhausting memory. | ||
440 | */ | ||
441 | #define LUAI_MAXCALLS 20000 | ||
442 | |||
443 | |||
444 | /* | ||
445 | @@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function | ||
446 | @* can use. | ||
447 | ** CHANGE it if you need lots of (Lua) stack space for your C | ||
448 | ** functions. This limit is arbitrary; its only purpose is to stop C | ||
449 | ** functions to consume unlimited stack space. (must be smaller than | ||
450 | ** -LUA_REGISTRYINDEX) | ||
451 | */ | ||
452 | #define LUAI_MAXCSTACK 8000 | ||
453 | |||
454 | |||
455 | /* | ||
456 | ** {================================================================== | ||
457 | ** CHANGE (to smaller values) the following definitions if your system | ||
458 | ** has a small C stack. (Or you may want to change them to larger | ||
459 | ** values if your system has a large C stack and these limits are | ||
460 | ** too rigid for you.) Some of these constants control the size of | ||
461 | ** stack-allocated arrays used by the compiler or the interpreter, while | ||
462 | ** others limit the maximum number of recursive calls that the compiler | ||
463 | ** or the interpreter can perform. Values too large may cause a C stack | ||
464 | ** overflow for some forms of deep constructs. | ||
465 | ** =================================================================== | ||
466 | */ | ||
467 | |||
468 | |||
469 | /* | ||
470 | @@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and | ||
471 | @* syntactical nested non-terminals in a program. | ||
472 | */ | ||
473 | #define LUAI_MAXCCALLS 200 | ||
474 | |||
475 | |||
476 | /* | ||
477 | @@ LUAI_MAXVARS is the maximum number of local variables per function | ||
478 | @* (must be smaller than 250). | ||
479 | */ | ||
480 | #define LUAI_MAXVARS 200 | ||
481 | |||
482 | |||
483 | /* | ||
484 | @@ LUAI_MAXUPVALUES is the maximum number of upvalues per function | ||
485 | @* (must be smaller than 250). | ||
486 | */ | ||
487 | #define LUAI_MAXUPVALUES 60 | ||
488 | |||
489 | |||
490 | /* | ||
491 | @@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. | ||
492 | */ | ||
493 | #define LUAL_BUFFERSIZE BUFSIZ | ||
494 | |||
495 | /* }================================================================== */ | ||
496 | |||
497 | |||
498 | |||
499 | |||
500 | /* | ||
501 | ** {================================================================== | ||
502 | @@ LUA_NUMBER is the type of numbers in Lua. | ||
503 | ** CHANGE the following definitions only if you want to build Lua | ||
504 | ** with a number type different from double. You may also need to | ||
505 | ** change lua_number2int & lua_number2integer. | ||
506 | ** =================================================================== | ||
507 | */ | ||
508 | |||
509 | #define LUA_NUMBER_DOUBLE | ||
510 | #define LUA_NUMBER double | ||
511 | |||
512 | /* | ||
513 | @@ LUAI_UACNUMBER is the result of an 'usual argument conversion' | ||
514 | @* over a number. | ||
515 | */ | ||
516 | #define LUAI_UACNUMBER double | ||
517 | |||
518 | |||
519 | /* | ||
520 | @@ LUA_NUMBER_SCAN is the format for reading numbers. | ||
521 | @@ LUA_NUMBER_FMT is the format for writing numbers. | ||
522 | @@ lua_number2str converts a number to a string. | ||
523 | @@ LUAI_MAXNUMBER2STR is maximum size of previous conversion. | ||
524 | @@ lua_str2number converts a string to a number. | ||
525 | */ | ||
526 | #define LUA_NUMBER_SCAN "%lf" | ||
527 | #define LUA_NUMBER_FMT "%.14g" | ||
528 | #define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) | ||
529 | #define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */ | ||
530 | #define lua_str2number(s,p) strtod((s), (p)) | ||
531 | |||
532 | |||
533 | /* | ||
534 | @@ The luai_num* macros define the primitive operations over numbers. | ||
535 | */ | ||
536 | #if defined(LUA_CORE) | ||
537 | #include <math.h> | ||
538 | #define luai_numadd(a,b) ((a)+(b)) | ||
539 | #define luai_numsub(a,b) ((a)-(b)) | ||
540 | #define luai_nummul(a,b) ((a)*(b)) | ||
541 | #define luai_numdiv(a,b) ((a)/(b)) | ||
542 | #define luai_nummod(a,b) ((a) - floor((a)/(b))*(b)) | ||
543 | #define luai_numpow(a,b) (pow(a,b)) | ||
544 | #define luai_numunm(a) (-(a)) | ||
545 | #define luai_numeq(a,b) ((a)==(b)) | ||
546 | #define luai_numlt(a,b) ((a)<(b)) | ||
547 | #define luai_numle(a,b) ((a)<=(b)) | ||
548 | #define luai_numisnan(a) (!luai_numeq((a), (a))) | ||
549 | #endif | ||
550 | |||
551 | |||
552 | /* | ||
553 | @@ lua_number2int is a macro to convert lua_Number to int. | ||
554 | @@ lua_number2integer is a macro to convert lua_Number to lua_Integer. | ||
555 | ** CHANGE them if you know a faster way to convert a lua_Number to | ||
556 | ** int (with any rounding method and without throwing errors) in your | ||
557 | ** system. In Pentium machines, a naive typecast from double to int | ||
558 | ** in C is extremely slow, so any alternative is worth trying. | ||
559 | */ | ||
560 | |||
561 | /* On a Pentium, resort to a trick */ | ||
562 | #if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \ | ||
563 | (defined(__i386) || defined (_M_IX86) || defined(__i386__)) | ||
564 | |||
565 | /* On a Microsoft compiler, use assembler */ | ||
566 | #if defined(_MSC_VER) | ||
567 | |||
568 | #define lua_number2int(i,d) __asm fld d __asm fistp i | ||
569 | #define lua_number2integer(i,n) lua_number2int(i, n) | ||
570 | |||
571 | /* the next trick should work on any Pentium, but sometimes clashes | ||
572 | with a DirectX idiosyncrasy */ | ||
573 | #else | ||
574 | |||
575 | union luai_Cast { double l_d; long l_l; }; | ||
576 | #define lua_number2int(i,d) \ | ||
577 | { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; } | ||
578 | #define lua_number2integer(i,n) lua_number2int(i, n) | ||
579 | |||
580 | #endif | ||
581 | |||
582 | |||
583 | /* this option always works, but may be slow */ | ||
584 | #else | ||
585 | #define lua_number2int(i,d) ((i)=(int)(d)) | ||
586 | #define lua_number2integer(i,d) ((i)=(lua_Integer)(d)) | ||
587 | |||
588 | #endif | ||
589 | |||
590 | |||
591 | /* | ||
592 | @@ LUA_TVALUE_ALIGN specifies extra alignment constraints for the | ||
593 | @@ tagged value structure to get better lua_Number alignment. | ||
594 | ** CHANGE it to an empty define if you want to save some space | ||
595 | ** at the cost of execution time. Note that this is only needed | ||
596 | ** for the x86 ABI on most POSIX systems, but not on Windows and | ||
597 | ** not for most other CPUs. If you change it then you need to follow | ||
598 | ** the instructions in ljit_x86.dash, too (look for TVALUE_SIZE). | ||
599 | */ | ||
600 | |||
601 | #if defined(LUA_NUMBER_DOUBLE) && defined(__GNUC__) && \ | ||
602 | (defined(__i386) || defined(__i386__)) && !defined(_WIN32) | ||
603 | #define LUA_TVALUE_ALIGN __attribute__ ((aligned(8))) | ||
604 | #else | ||
605 | #define LUA_TVALUE_ALIGN | ||
606 | #endif | ||
607 | |||
608 | /* }================================================================== */ | ||
609 | |||
610 | |||
611 | /* | ||
612 | @@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment. | ||
613 | ** CHANGE it if your system requires alignments larger than double. (For | ||
614 | ** instance, if your system supports long doubles and they must be | ||
615 | ** aligned in 16-byte boundaries, then you should add long double in the | ||
616 | ** union.) Probably you do not need to change this. | ||
617 | */ | ||
618 | #define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; } | ||
619 | |||
620 | |||
621 | /* | ||
622 | @@ LUAI_THROW/LUAI_TRY define how Lua does exception handling. | ||
623 | ** CHANGE them if you prefer to use longjmp/setjmp even with C++ | ||
624 | ** or if want/don't to use _longjmp/_setjmp instead of regular | ||
625 | ** longjmp/setjmp. By default, Lua handles errors with exceptions when | ||
626 | ** compiling as C++ code, with _longjmp/_setjmp when asked to use them, | ||
627 | ** and with longjmp/setjmp otherwise. | ||
628 | */ | ||
629 | #if defined(__cplusplus) | ||
630 | /* C++ exceptions */ | ||
631 | #define LUAI_THROW(L,c) throw(c) | ||
632 | #define LUAI_TRY(L,c,a) try { a } catch(...) \ | ||
633 | { if ((c)->status == 0) (c)->status = -1; } | ||
634 | #define luai_jmpbuf int /* dummy variable */ | ||
635 | |||
636 | #elif defined(LUA_USE_ULONGJMP) | ||
637 | /* in Unix, try _longjmp/_setjmp (more efficient) */ | ||
638 | #define LUAI_THROW(L,c) _longjmp((c)->b, 1) | ||
639 | #define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a } | ||
640 | #define luai_jmpbuf jmp_buf | ||
641 | |||
642 | #else | ||
643 | /* default handling with long jumps */ | ||
644 | #define LUAI_THROW(L,c) longjmp((c)->b, 1) | ||
645 | #define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } | ||
646 | #define luai_jmpbuf jmp_buf | ||
647 | |||
648 | #endif | ||
649 | |||
650 | |||
651 | /* | ||
652 | @@ LUA_MAXCAPTURES is the maximum number of captures that a pattern | ||
653 | @* can do during pattern-matching. | ||
654 | ** CHANGE it if you need more captures. This limit is arbitrary. | ||
655 | */ | ||
656 | #define LUA_MAXCAPTURES 32 | ||
657 | |||
658 | |||
659 | /* | ||
660 | @@ lua_tmpnam is the function that the OS library uses to create a | ||
661 | @* temporary name. | ||
662 | @@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam. | ||
663 | ** CHANGE them if you have an alternative to tmpnam (which is considered | ||
664 | ** insecure) or if you want the original tmpnam anyway. By default, Lua | ||
665 | ** uses tmpnam except when POSIX is available, where it uses mkstemp. | ||
666 | */ | ||
667 | #if defined(loslib_c) || defined(luaall_c) | ||
668 | |||
669 | #if defined(LUA_USE_MKSTEMP) | ||
670 | #include <unistd.h> | ||
671 | #define LUA_TMPNAMBUFSIZE 32 | ||
672 | #define lua_tmpnam(b,e) { \ | ||
673 | strcpy(b, "/tmp/lua_XXXXXX"); \ | ||
674 | e = mkstemp(b); \ | ||
675 | if (e != -1) close(e); \ | ||
676 | e = (e == -1); } | ||
677 | |||
678 | #else | ||
679 | #define LUA_TMPNAMBUFSIZE L_tmpnam | ||
680 | #define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); } | ||
681 | #endif | ||
682 | |||
683 | #endif | ||
684 | |||
685 | |||
686 | /* | ||
687 | @@ lua_popen spawns a new process connected to the current one through | ||
688 | @* the file streams. | ||
689 | ** CHANGE it if you have a way to implement it in your system. | ||
690 | */ | ||
691 | #if defined(LUA_USE_POPEN) | ||
692 | |||
693 | #define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m)) | ||
694 | #define lua_pclose(L,file) ((void)L, (pclose(file) != -1)) | ||
695 | |||
696 | #elif defined(LUA_WIN) | ||
697 | |||
698 | #define lua_popen(L,c,m) ((void)L, _popen(c,m)) | ||
699 | #define lua_pclose(L,file) ((void)L, (_pclose(file) != -1)) | ||
700 | |||
701 | #else | ||
702 | |||
703 | #define lua_popen(L,c,m) ((void)((void)c, m), \ | ||
704 | luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0) | ||
705 | #define lua_pclose(L,file) ((void)((void)L, file), 0) | ||
706 | |||
707 | #endif | ||
708 | |||
709 | /* | ||
710 | @@ LUA_DL_* define which dynamic-library system Lua should use. | ||
711 | ** CHANGE here if Lua has problems choosing the appropriate | ||
712 | ** dynamic-library system for your platform (either Windows' DLL, Mac's | ||
713 | ** dyld, or Unix's dlopen). If your system is some kind of Unix, there | ||
714 | ** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for | ||
715 | ** it. To use dlopen you also need to adapt the src/Makefile (probably | ||
716 | ** adding -ldl to the linker options), so Lua does not select it | ||
717 | ** automatically. (When you change the makefile to add -ldl, you must | ||
718 | ** also add -DLUA_USE_DLOPEN.) | ||
719 | ** If you do not want any kind of dynamic library, undefine all these | ||
720 | ** options. | ||
721 | ** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD. | ||
722 | */ | ||
723 | #if defined(LUA_USE_DLOPEN) | ||
724 | #define LUA_DL_DLOPEN | ||
725 | #endif | ||
726 | |||
727 | #if defined(LUA_WIN) | ||
728 | #define LUA_DL_DLL | ||
729 | #endif | ||
730 | |||
731 | |||
732 | /* | ||
733 | @@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State | ||
734 | @* (the data goes just *before* the lua_State pointer). | ||
735 | ** CHANGE (define) this if you really need that. This value must be | ||
736 | ** a multiple of the maximum alignment required for your machine. | ||
737 | */ | ||
738 | #define LUAI_EXTRASPACE 0 | ||
739 | |||
740 | |||
741 | /* | ||
742 | @@ luai_userstate* allow user-specific actions on threads. | ||
743 | ** CHANGE them if you defined LUAI_EXTRASPACE and need to do something | ||
744 | ** extra when a thread is created/deleted/resumed/yielded. | ||
745 | */ | ||
746 | #define luai_userstateopen(L) ((void)L) | ||
747 | #define luai_userstateclose(L) ((void)L) | ||
748 | #define luai_userstatethread(L,L1) ((void)L) | ||
749 | #define luai_userstatefree(L) ((void)L) | ||
750 | #define luai_userstateresume(L,n) ((void)L) | ||
751 | #define luai_userstateyield(L,n) ((void)L) | ||
752 | |||
753 | |||
754 | /* | ||
755 | @@ LUA_INTFRMLEN is the length modifier for integer conversions | ||
756 | @* in 'string.format'. | ||
757 | @@ LUA_INTFRM_T is the integer type correspoding to the previous length | ||
758 | @* modifier. | ||
759 | ** CHANGE them if your system supports long long or does not support long. | ||
760 | */ | ||
761 | |||
762 | #if defined(LUA_USELONGLONG) | ||
763 | |||
764 | #define LUA_INTFRMLEN "ll" | ||
765 | #define LUA_INTFRM_T long long | ||
766 | |||
767 | #else | ||
768 | |||
769 | #define LUA_INTFRMLEN "l" | ||
770 | #define LUA_INTFRM_T long | ||
771 | |||
772 | #endif | ||
773 | |||
774 | |||
775 | |||
776 | /* =================================================================== */ | ||
777 | |||
778 | /* | ||
779 | ** Local configuration. You can use this space to add your redefinitions | ||
780 | ** without modifying the main part of the file. | ||
781 | */ | ||
782 | |||
783 | |||
784 | |||
785 | #endif | ||
786 | |||