"Fossies" - the Fresh Open Source Software Archive

Member "redis-5.0.6/deps/lua/src/luaconf.h" (25 Sep 2019, 22299 Bytes) of package /linux/misc/redis-5.0.6.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    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        "lua"
  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 #undef LUA_COMPAT_GETN
  323 
  324 /*
  325 @@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib.
  326 ** CHANGE it to undefined as soon as you do not need a global 'loadlib'
  327 ** function (the function is still available as 'package.loadlib').
  328 */
  329 #undef LUA_COMPAT_LOADLIB
  330 
  331 /*
  332 @@ LUA_COMPAT_VARARG controls compatibility with old vararg feature.
  333 ** CHANGE it to undefined as soon as your programs use only '...' to
  334 ** access vararg parameters (instead of the old 'arg' table).
  335 */
  336 #define LUA_COMPAT_VARARG
  337 
  338 /*
  339 @@ LUA_COMPAT_MOD controls compatibility with old math.mod function.
  340 ** CHANGE it to undefined as soon as your programs use 'math.fmod' or
  341 ** the new '%' operator instead of 'math.mod'.
  342 */
  343 #define LUA_COMPAT_MOD
  344 
  345 /*
  346 @@ LUA_COMPAT_LSTR controls compatibility with old long string nesting
  347 @* facility.
  348 ** CHANGE it to 2 if you want the old behaviour, or undefine it to turn
  349 ** off the advisory error when nesting [[...]].
  350 */
  351 #define LUA_COMPAT_LSTR     1
  352 
  353 /*
  354 @@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name.
  355 ** CHANGE it to undefined as soon as you rename 'string.gfind' to
  356 ** 'string.gmatch'.
  357 */
  358 #define LUA_COMPAT_GFIND
  359 
  360 /*
  361 @@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib'
  362 @* behavior.
  363 ** CHANGE it to undefined as soon as you replace to 'luaL_register'
  364 ** your uses of 'luaL_openlib'
  365 */
  366 #define LUA_COMPAT_OPENLIB
  367 
  368 
  369 
  370 /*
  371 @@ luai_apicheck is the assert macro used by the Lua-C API.
  372 ** CHANGE luai_apicheck if you want Lua to perform some checks in the
  373 ** parameters it gets from API calls. This may slow down the interpreter
  374 ** a bit, but may be quite useful when debugging C code that interfaces
  375 ** with Lua. A useful redefinition is to use assert.h.
  376 */
  377 #if defined(LUA_USE_APICHECK)
  378 #include <assert.h>
  379 #define luai_apicheck(L,o)  { (void)L; assert(o); }
  380 #else
  381 #define luai_apicheck(L,o)  { (void)L; }
  382 #endif
  383 
  384 
  385 /*
  386 @@ LUAI_BITSINT defines the number of bits in an int.
  387 ** CHANGE here if Lua cannot automatically detect the number of bits of
  388 ** your machine. Probably you do not need to change this.
  389 */
  390 /* avoid overflows in comparison */
  391 #if INT_MAX-20 < 32760
  392 #define LUAI_BITSINT    16
  393 #elif INT_MAX > 2147483640L
  394 /* int has at least 32 bits */
  395 #define LUAI_BITSINT    32
  396 #else
  397 #error "you must define LUA_BITSINT with number of bits in an integer"
  398 #endif
  399 
  400 
  401 /*
  402 @@ LUAI_UINT32 is an unsigned integer with at least 32 bits.
  403 @@ LUAI_INT32 is an signed integer with at least 32 bits.
  404 @@ LUAI_UMEM is an unsigned integer big enough to count the total
  405 @* memory used by Lua.
  406 @@ LUAI_MEM is a signed integer big enough to count the total memory
  407 @* used by Lua.
  408 ** CHANGE here if for some weird reason the default definitions are not
  409 ** good enough for your machine. (The definitions in the 'else'
  410 ** part always works, but may waste space on machines with 64-bit
  411 ** longs.) Probably you do not need to change this.
  412 */
  413 #if LUAI_BITSINT >= 32
  414 #define LUAI_UINT32 unsigned int
  415 #define LUAI_INT32  int
  416 #define LUAI_MAXINT32   INT_MAX
  417 #define LUAI_UMEM   size_t
  418 #define LUAI_MEM    ptrdiff_t
  419 #else
  420 /* 16-bit ints */
  421 #define LUAI_UINT32 unsigned long
  422 #define LUAI_INT32  long
  423 #define LUAI_MAXINT32   LONG_MAX
  424 #define LUAI_UMEM   unsigned long
  425 #define LUAI_MEM    long
  426 #endif
  427 
  428 
  429 /*
  430 @@ LUAI_MAXCALLS limits the number of nested calls.
  431 ** CHANGE it if you need really deep recursive calls. This limit is
  432 ** arbitrary; its only purpose is to stop infinite recursion before
  433 ** exhausting memory.
  434 */
  435 #define LUAI_MAXCALLS   20000
  436 
  437 
  438 /*
  439 @@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function
  440 @* can use.
  441 ** CHANGE it if you need lots of (Lua) stack space for your C
  442 ** functions. This limit is arbitrary; its only purpose is to stop C
  443 ** functions to consume unlimited stack space. (must be smaller than
  444 ** -LUA_REGISTRYINDEX)
  445 */
  446 #define LUAI_MAXCSTACK  8000
  447 
  448 
  449 
  450 /*
  451 ** {==================================================================
  452 ** CHANGE (to smaller values) the following definitions if your system
  453 ** has a small C stack. (Or you may want to change them to larger
  454 ** values if your system has a large C stack and these limits are
  455 ** too rigid for you.) Some of these constants control the size of
  456 ** stack-allocated arrays used by the compiler or the interpreter, while
  457 ** others limit the maximum number of recursive calls that the compiler
  458 ** or the interpreter can perform. Values too large may cause a C stack
  459 ** overflow for some forms of deep constructs.
  460 ** ===================================================================
  461 */
  462 
  463 
  464 /*
  465 @@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and
  466 @* syntactical nested non-terminals in a program.
  467 */
  468 #define LUAI_MAXCCALLS      200
  469 
  470 
  471 /*
  472 @@ LUAI_MAXVARS is the maximum number of local variables per function
  473 @* (must be smaller than 250).
  474 */
  475 #define LUAI_MAXVARS        200
  476 
  477 
  478 /*
  479 @@ LUAI_MAXUPVALUES is the maximum number of upvalues per function
  480 @* (must be smaller than 250).
  481 */
  482 #define LUAI_MAXUPVALUES    60
  483 
  484 
  485 /*
  486 @@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
  487 */
  488 #define LUAL_BUFFERSIZE     BUFSIZ
  489 
  490 /* }================================================================== */
  491 
  492 
  493 
  494 
  495 /*
  496 ** {==================================================================
  497 @@ LUA_NUMBER is the type of numbers in Lua.
  498 ** CHANGE the following definitions only if you want to build Lua
  499 ** with a number type different from double. You may also need to
  500 ** change lua_number2int & lua_number2integer.
  501 ** ===================================================================
  502 */
  503 
  504 #define LUA_NUMBER_DOUBLE
  505 #define LUA_NUMBER  double
  506 
  507 /*
  508 @@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
  509 @* over a number.
  510 */
  511 #define LUAI_UACNUMBER  double
  512 
  513 
  514 /*
  515 @@ LUA_NUMBER_SCAN is the format for reading numbers.
  516 @@ LUA_NUMBER_FMT is the format for writing numbers.
  517 @@ lua_number2str converts a number to a string.
  518 @@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
  519 @@ lua_str2number converts a string to a number.
  520 */
  521 #define LUA_NUMBER_SCAN     "%lf"
  522 #define LUA_NUMBER_FMT      "%.14g"
  523 #define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))
  524 #define LUAI_MAXNUMBER2STR  32 /* 16 digits, sign, point, and \0 */
  525 #define lua_str2number(s,p) strtod((s), (p))
  526 
  527 
  528 /*
  529 @@ The luai_num* macros define the primitive operations over numbers.
  530 */
  531 #if defined(LUA_CORE)
  532 #include <math.h>
  533 #define luai_numadd(a,b)    ((a)+(b))
  534 #define luai_numsub(a,b)    ((a)-(b))
  535 #define luai_nummul(a,b)    ((a)*(b))
  536 #define luai_numdiv(a,b)    ((a)/(b))
  537 #define luai_nummod(a,b)    ((a) - floor((a)/(b))*(b))
  538 #define luai_numpow(a,b)    (pow(a,b))
  539 #define luai_numunm(a)      (-(a))
  540 #define luai_numeq(a,b)     ((a)==(b))
  541 #define luai_numlt(a,b)     ((a)<(b))
  542 #define luai_numle(a,b)     ((a)<=(b))
  543 #define luai_numisnan(a)    (!luai_numeq((a), (a)))
  544 #endif
  545 
  546 
  547 /*
  548 @@ lua_number2int is a macro to convert lua_Number to int.
  549 @@ lua_number2integer is a macro to convert lua_Number to lua_Integer.
  550 ** CHANGE them if you know a faster way to convert a lua_Number to
  551 ** int (with any rounding method and without throwing errors) in your
  552 ** system. In Pentium machines, a naive typecast from double to int
  553 ** in C is extremely slow, so any alternative is worth trying.
  554 */
  555 
  556 /* On a Pentium, resort to a trick */
  557 #if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \
  558     (defined(__i386) || defined (_M_IX86) || defined(__i386__))
  559 
  560 /* On a Microsoft compiler, use assembler */
  561 #if defined(_MSC_VER)
  562 
  563 #define lua_number2int(i,d)   __asm fld d   __asm fistp i
  564 #define lua_number2integer(i,n)     lua_number2int(i, n)
  565 
  566 /* the next trick should work on any Pentium, but sometimes clashes
  567    with a DirectX idiosyncrasy */
  568 #else
  569 
  570 union luai_Cast { double l_d; long l_l; };
  571 #define lua_number2int(i,d) \
  572   { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }
  573 #define lua_number2integer(i,n)     lua_number2int(i, n)
  574 
  575 #endif
  576 
  577 
  578 /* this option always works, but may be slow */
  579 #else
  580 #define lua_number2int(i,d) ((i)=(int)(d))
  581 #define lua_number2integer(i,d) ((i)=(lua_Integer)(d))
  582 
  583 #endif
  584 
  585 /* }================================================================== */
  586 
  587 
  588 /*
  589 @@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment.
  590 ** CHANGE it if your system requires alignments larger than double. (For
  591 ** instance, if your system supports long doubles and they must be
  592 ** aligned in 16-byte boundaries, then you should add long double in the
  593 ** union.) Probably you do not need to change this.
  594 */
  595 #define LUAI_USER_ALIGNMENT_T   union { double u; void *s; long l; }
  596 
  597 
  598 /*
  599 @@ LUAI_THROW/LUAI_TRY define how Lua does exception handling.
  600 ** CHANGE them if you prefer to use longjmp/setjmp even with C++
  601 ** or if want/don't to use _longjmp/_setjmp instead of regular
  602 ** longjmp/setjmp. By default, Lua handles errors with exceptions when
  603 ** compiling as C++ code, with _longjmp/_setjmp when asked to use them,
  604 ** and with longjmp/setjmp otherwise.
  605 */
  606 #if defined(__cplusplus)
  607 /* C++ exceptions */
  608 #define LUAI_THROW(L,c) throw(c)
  609 #define LUAI_TRY(L,c,a) try { a } catch(...) \
  610     { if ((c)->status == 0) (c)->status = -1; }
  611 #define luai_jmpbuf int  /* dummy variable */
  612 
  613 #elif defined(LUA_USE_ULONGJMP)
  614 /* in Unix, try _longjmp/_setjmp (more efficient) */
  615 #define LUAI_THROW(L,c) _longjmp((c)->b, 1)
  616 #define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }
  617 #define luai_jmpbuf jmp_buf
  618 
  619 #else
  620 /* default handling with long jumps */
  621 #define LUAI_THROW(L,c) longjmp((c)->b, 1)
  622 #define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }
  623 #define luai_jmpbuf jmp_buf
  624 
  625 #endif
  626 
  627 
  628 /*
  629 @@ LUA_MAXCAPTURES is the maximum number of captures that a pattern
  630 @* can do during pattern-matching.
  631 ** CHANGE it if you need more captures. This limit is arbitrary.
  632 */
  633 #define LUA_MAXCAPTURES     32
  634 
  635 
  636 /*
  637 @@ lua_tmpnam is the function that the OS library uses to create a
  638 @* temporary name.
  639 @@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam.
  640 ** CHANGE them if you have an alternative to tmpnam (which is considered
  641 ** insecure) or if you want the original tmpnam anyway.  By default, Lua
  642 ** uses tmpnam except when POSIX is available, where it uses mkstemp.
  643 */
  644 #if defined(loslib_c) || defined(luaall_c)
  645 
  646 #if defined(LUA_USE_MKSTEMP)
  647 #include <unistd.h>
  648 #define LUA_TMPNAMBUFSIZE   32
  649 #define lua_tmpnam(b,e) { \
  650     strcpy(b, "/tmp/lua_XXXXXX"); \
  651     e = mkstemp(b); \
  652     if (e != -1) close(e); \
  653     e = (e == -1); }
  654 
  655 #else
  656 #define LUA_TMPNAMBUFSIZE   L_tmpnam
  657 #define lua_tmpnam(b,e)     { e = (tmpnam(b) == NULL); }
  658 #endif
  659 
  660 #endif
  661 
  662 
  663 /*
  664 @@ lua_popen spawns a new process connected to the current one through
  665 @* the file streams.
  666 ** CHANGE it if you have a way to implement it in your system.
  667 */
  668 #if defined(LUA_USE_POPEN)
  669 
  670 #define lua_popen(L,c,m)    ((void)L, fflush(NULL), popen(c,m))
  671 #define lua_pclose(L,file)  ((void)L, (pclose(file) != -1))
  672 
  673 #elif defined(LUA_WIN)
  674 
  675 #define lua_popen(L,c,m)    ((void)L, _popen(c,m))
  676 #define lua_pclose(L,file)  ((void)L, (_pclose(file) != -1))
  677 
  678 #else
  679 
  680 #define lua_popen(L,c,m)    ((void)((void)c, m),  \
  681         luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
  682 #define lua_pclose(L,file)      ((void)((void)L, file), 0)
  683 
  684 #endif
  685 
  686 /*
  687 @@ LUA_DL_* define which dynamic-library system Lua should use.
  688 ** CHANGE here if Lua has problems choosing the appropriate
  689 ** dynamic-library system for your platform (either Windows' DLL, Mac's
  690 ** dyld, or Unix's dlopen). If your system is some kind of Unix, there
  691 ** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for
  692 ** it.  To use dlopen you also need to adapt the src/Makefile (probably
  693 ** adding -ldl to the linker options), so Lua does not select it
  694 ** automatically.  (When you change the makefile to add -ldl, you must
  695 ** also add -DLUA_USE_DLOPEN.)
  696 ** If you do not want any kind of dynamic library, undefine all these
  697 ** options.
  698 ** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD.
  699 */
  700 #if defined(LUA_USE_DLOPEN)
  701 #define LUA_DL_DLOPEN
  702 #endif
  703 
  704 #if defined(LUA_WIN)
  705 #define LUA_DL_DLL
  706 #endif
  707 
  708 
  709 /*
  710 @@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State
  711 @* (the data goes just *before* the lua_State pointer).
  712 ** CHANGE (define) this if you really need that. This value must be
  713 ** a multiple of the maximum alignment required for your machine.
  714 */
  715 #define LUAI_EXTRASPACE     0
  716 
  717 
  718 /*
  719 @@ luai_userstate* allow user-specific actions on threads.
  720 ** CHANGE them if you defined LUAI_EXTRASPACE and need to do something
  721 ** extra when a thread is created/deleted/resumed/yielded.
  722 */
  723 #define luai_userstateopen(L)       ((void)L)
  724 #define luai_userstateclose(L)      ((void)L)
  725 #define luai_userstatethread(L,L1)  ((void)L)
  726 #define luai_userstatefree(L)       ((void)L)
  727 #define luai_userstateresume(L,n)   ((void)L)
  728 #define luai_userstateyield(L,n)    ((void)L)
  729 
  730 
  731 /*
  732 @@ LUA_INTFRMLEN is the length modifier for integer conversions
  733 @* in 'string.format'.
  734 @@ LUA_INTFRM_T is the integer type correspoding to the previous length
  735 @* modifier.
  736 ** CHANGE them if your system supports long long or does not support long.
  737 */
  738 
  739 #if defined(LUA_USELONGLONG)
  740 
  741 #define LUA_INTFRMLEN       "ll"
  742 #define LUA_INTFRM_T        long long
  743 
  744 #else
  745 
  746 #define LUA_INTFRMLEN       "l"
  747 #define LUA_INTFRM_T        long
  748 
  749 #endif
  750 
  751 
  752 
  753 /* =================================================================== */
  754 
  755 /*
  756 ** Local configuration. You can use this space to add your redefinitions
  757 ** without modifying the main part of the file.
  758 */
  759 
  760 
  761 
  762 #endif
  763