Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

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