6502/l65
1
0
Fork 0
mirror of https://github.com/g012/l65.git synced 2025-04-28 09:37:25 +00:00
Code Issues Projects Releases Wiki Activity
l65/lua.h
g012 29f5666b20 Added build.zig to cross compile 
Warning: currently you need to edit ConfigHeader.zig in Zig's std
library, and comment "try output.appendSlice(c_generated_line);"
2024-03-12 16:01:12 +01:00

21903 lines
688 KiB
C++
Raw Permalink Blame History

/*
* Lua 5.3.4 as one file, STB style.
* Options from Makefile: LUA_USE_LINUX, LUA_USE_MACOSX, LUA_USE_POSIX, LUA_USE_DLOPEN, LUA_USE_C89
* Add extern "C" before including if needed.
*/
/******************************************************************************
* Copyright (C) 1994-2017 Lua.org, PUC-Rio.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
******************************************************************************/
#ifdef LUA_IMPLEMENTATION
#define LUA_CORE
/*__lprefix.h__*/
/*
** Allows POSIX/XSI stuff
*/
#if !defined(LUA_USE_C89) /* { */
#if !defined(_XOPEN_SOURCE)
#define _XOPEN_SOURCE 600
#elif _XOPEN_SOURCE == 0
#undef _XOPEN_SOURCE /* use -D_XOPEN_SOURCE=0 to undefine it */
#endif
/*
** Allows manipulation of large files in gcc and some other compilers
*/
#if !defined(LUA_32BITS) && !defined(_FILE_OFFSET_BITS)
#define _LARGEFILE_SOURCE 1
#define _FILE_OFFSET_BITS 64
#endif
#endif /* } */
/*
** Windows stuff
*/
#if defined(_WIN32) /* { */
#if !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS /* avoid warnings about ISO C functions */
#endif
#endif /* } */
#endif
/***************************************************************************
* HEADER
**************************************************************************/
#ifndef lua_h
#define lua_h
#include <limits.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
/*__luaconf.h__*/
/*
** ===================================================================
** Search for "@@" to find all configurable definitions.
** ===================================================================
*/
/*
** {====================================================================
** System Configuration: macros to adapt (if needed) Lua to some
** particular platform, for instance compiling it with 32-bit numbers or
** restricting it to C89.
** =====================================================================
*/
/*
@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. You
** can also define LUA_32BITS in the make file, but changing here you
** ensure that all software connected to Lua will be compiled with the
** same configuration.
*/
/* #define LUA_32BITS */
/*
@@ LUA_USE_C89 controls the use of non-ISO-C89 features.
** Define it if you want Lua to avoid the use of a few C99 features
** or Windows-specific features on Windows.
*/
/* #define LUA_USE_C89 */
/*
** By default, Lua on Windows use (some) specific Windows features
*/
#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE)
#define LUA_USE_WINDOWS /* enable goodies for regular Windows */
#endif
#if defined(LUA_USE_WINDOWS)
#define LUA_DL_DLL /* enable support for DLL */
#define LUA_USE_C89 /* broadly, Windows is C89 */
#endif
#if defined(LUA_USE_LINUX)
#define LUA_USE_POSIX
#define LUA_USE_DLOPEN /* needs an extra library: -ldl */
#define LUA_USE_READLINE /* needs some extra libraries */
#endif
#if defined(LUA_USE_MACOSX)
#define LUA_USE_POSIX
#define LUA_USE_DLOPEN /* MacOS does not need -ldl */
#define LUA_USE_READLINE /* needs an extra library: -lreadline */
#endif
/*
@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for
** C89 ('long' and 'double'); Windows always has '__int64', so it does
** not need to use this case.
*/
#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS)
#define LUA_C89_NUMBERS
#endif
/*
@@ LUAI_BITSINT defines the (minimum) number of bits in an 'int'.
*/
/* avoid undefined shifts */
#if ((INT_MAX >> 15) >> 15) >= 1
#define LUAI_BITSINT 32
#else
/* 'int' always must have at least 16 bits */
#define LUAI_BITSINT 16
#endif
/*
@@ LUA_INT_TYPE defines the type for Lua integers.
@@ LUA_FLOAT_TYPE defines the type for Lua floats.
** Lua should work fine with any mix of these options (if supported
** by your C compiler). The usual configurations are 64-bit integers
** and 'double' (the default), 32-bit integers and 'float' (for
** restricted platforms), and 'long'/'double' (for C compilers not
** compliant with C99, which may not have support for 'long long').
*/
/* predefined options for LUA_INT_TYPE */
#define LUA_INT_INT 1
#define LUA_INT_LONG 2
#define LUA_INT_LONGLONG 3
/* predefined options for LUA_FLOAT_TYPE */
#define LUA_FLOAT_FLOAT 1
#define LUA_FLOAT_DOUBLE 2
#define LUA_FLOAT_LONGDOUBLE 3
#if defined(LUA_32BITS) /* { */
/*
** 32-bit integers and 'float'
*/
#if LUAI_BITSINT >= 32 /* use 'int' if big enough */
#define LUA_INT_TYPE LUA_INT_INT
#else /* otherwise use 'long' */
#define LUA_INT_TYPE LUA_INT_LONG
#endif
#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT
#elif defined(LUA_C89_NUMBERS) /* }{ */
/*
** largest types available for C89 ('long' and 'double')
*/
#define LUA_INT_TYPE LUA_INT_LONG
#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE
#endif /* } */
/*
** default configuration for 64-bit Lua ('long long' and 'double')
*/
#if !defined(LUA_INT_TYPE)
#define LUA_INT_TYPE LUA_INT_LONGLONG
#endif
#if !defined(LUA_FLOAT_TYPE)
#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE
#endif
/* }================================================================== */
/*
** {==================================================================
** Configuration for Paths.
** ===================================================================
*/
/*
** LUA_PATH_SEP is the character that separates templates in a path.
** LUA_PATH_MARK is the string that marks the substitution points in a
** template.
** LUA_EXEC_DIR in a Windows path is replaced by the executable's
** directory.
*/
#define LUA_PATH_SEP ";"
#define LUA_PATH_MARK "?"
#define LUA_EXEC_DIR "!"
/*
@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
** Lua libraries.
@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
** C libraries.
** CHANGE them if your machine has a non-conventional directory
** hierarchy or if you want to install your libraries in
** non-conventional directories.
*/
#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
#if defined(_WIN32) /* { */
/*
** In Windows, any exclamation mark ('!') in the path is replaced by the
** path of the directory of the executable file of the current process.
*/
#define LUA_LDIR "!\\lua\\"
#define LUA_CDIR "!\\"
#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\"
#define LUA_PATH_DEFAULT \
LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \
LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \
LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \
".\\?.lua;" ".\\?\\init.lua"
#define LUA_CPATH_DEFAULT \
LUA_CDIR"?.dll;" \
LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \
LUA_CDIR"loadall.dll;" ".\\?.dll"
#else /* }{ */
#define LUA_ROOT "/usr/local/"
#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/"
#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/"
#define LUA_PATH_DEFAULT \
LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \
LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \
"./?.lua;" "./?/init.lua"
#define LUA_CPATH_DEFAULT \
LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so"
#endif /* } */
/*
@@ LUA_DIRSEP is the directory separator (for submodules).
** CHANGE it if your machine does not use "/" as the directory separator
** and is not Windows. (On Windows Lua automatically uses "\".)
*/
#if defined(_WIN32)
#define LUA_DIRSEP "\\"
#else
#define LUA_DIRSEP "/"
#endif
/* }================================================================== */
/*
** {==================================================================
** Marks for exported symbols in the C code
** ===================================================================
*/
/*
@@ LUA_API is a mark for all core API functions.
@@ LUALIB_API is a mark for all auxiliary library functions.
@@ LUAMOD_API is a mark for all standard library opening functions.
** CHANGE them if you need to define those functions in some special way.
** For instance, if you want to create one Windows DLL with the core and
** the libraries, you may want to use the following definition (define
** LUA_BUILD_AS_DLL to get it).
*/
#if defined(LUA_BUILD_AS_DLL) /* { */
#if defined(LUA_CORE) || defined(LUA_LIB) /* { */
#define LUA_API __declspec(dllexport)
#else /* }{ */
#define LUA_API __declspec(dllimport)
#endif /* } */
#else /* }{ */
#define LUA_API extern
#endif /* } */
/* more often than not the libs go together with the core */
#define LUALIB_API LUA_API
#define LUAMOD_API LUALIB_API
/*
@@ LUAI_FUNC is a mark for all extern functions that are not to be
** exported to outside modules.
@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
** that are not to be exported to outside modules (LUAI_DDEF for
** definitions and LUAI_DDEC for declarations).
** CHANGE them if you need to mark them in some special way. Elf/gcc
** (versions 3.2 and later) mark them as "hidden" to optimize access
** when Lua is compiled as a shared library. Not all elf targets support
** this attribute. Unfortunately, gcc does not offer a way to luai_check
** whether the target offers that support, and those without support
** give a warning about it. To avoid these warnings, change to the
** default definition.
*/
#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
defined(__ELF__) /* { */
#define LUAI_FUNC __attribute__((visibility("hidden"))) extern
#else /* }{ */
#define LUAI_FUNC extern
#endif /* } */
#define LUAI_DDEC LUAI_FUNC
#define LUAI_DDEF /* empty */
/* }================================================================== */
/*
** {==================================================================
** Compatibility with previous versions
** ===================================================================
*/
/*
@@ LUA_COMPAT_5_2 controls other macros for compatibility with Lua 5.2.
@@ LUA_COMPAT_5_1 controls other macros for compatibility with Lua 5.1.
** You can define it to get all options, or change specific options
** to fit your specific needs.
*/
#if defined(LUA_COMPAT_5_2) /* { */
/*
@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
** functions in the mathematical library.
*/
#define LUA_COMPAT_MATHLIB
/*
@@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'.
*/
#define LUA_COMPAT_BITLIB
/*
@@ LUA_COMPAT_IPAIRS controls the effectiveness of the __ipairs metamethod.
*/
#define LUA_COMPAT_IPAIRS
/*
@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for
** manipulating other integer types (lua_pushunsigned, lua_tounsigned,
** luaL_checkint, luaL_checklong, etc.)
*/
#define LUA_COMPAT_APIINTCASTS
#endif /* } */
#if defined(LUA_COMPAT_5_1) /* { */
/* Incompatibilities from 5.2 -> 5.3 */
#define LUA_COMPAT_MATHLIB
#define LUA_COMPAT_APIINTCASTS
/*
@@ LUA_COMPAT_UNPACK controls the presence of global 'luai_unpack'.
** You can replace it with 'table.luai_unpack'.
*/
#define LUA_COMPAT_UNPACK
/*
@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.
** You can replace it with 'package.searchers'.
*/
#define LUA_COMPAT_LOADERS
/*
@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
** You can call your C function directly (with light C functions).
*/
#define lua_cpcall(L,f,u) \
(lua_pushcfunction(L, (f)), \
lua_pushlightuserdata(L,(u)), \
lua_pcall(L,1,0,0))
/*
@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.
** You can rewrite 'log10(x)' as 'log(x, 10)'.
*/
#define LUA_COMPAT_LOG10
/*
@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
** library. You can rewrite 'loadstring(s)' as 'load(s)'.
*/
#define LUA_COMPAT_LOADSTRING
/*
@@ LUA_COMPAT_MAXN defines the function 'luai_maxn' in the table library.
*/
#define LUA_COMPAT_MAXN
/*
@@ The following macros supply trivial compatibility for some
** changes in the API. The macros themselves document how to
** change your code to avoid using them.
*/
#define lua_strlen(L,i) lua_rawlen(L, (i))
#define lua_objlen(L,i) lua_rawlen(L, (i))
#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ)
#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT)
/*
@@ LUA_COMPAT_MODULE controls compatibility with previous
** module functions 'module' (Lua) and 'luaL_register' (C).
*/
#define LUA_COMPAT_MODULE
#endif /* } */
/*
@@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a
@@ a float mark ('.0').
** This macro is not on by default even in compatibility mode,
** because this is not really an incompatibility.
*/
/* #define LUA_COMPAT_FLOATSTRING */
/* }================================================================== */
/*
** {==================================================================
** Configuration for Numbers.
** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_*
** satisfy your needs.
** ===================================================================
*/
/*
@@ LUA_NUMBER is the floating-point type used by Lua.
@@ LUAI_UACNUMBER is the result of a 'default argument promotion'
@@ over a floating number.
@@ luai_l_mathlim(x) corrects limit name 'x' to the proper float type
** by prefixing it with one of FLT/DBL/LDBL.
@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
@@ LUA_NUMBER_FMT is the format for writing floats.
@@ lua_number2str converts a float to a string.
@@ luai_l_mathop allows the addition of an 'l' or 'f' to all math operations.
@@ luai_l_floor takes the floor of a float.
@@ lua_str2number converts a decimal numeric string to a number.
*/
/* The following definitions are good for most cases here */
#define luai_l_floor(x) (luai_l_mathop(floor)(x))
#define lua_number2str(s,sz,n) \
luai_l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n))
/*
@@ lua_numbertointeger converts a float number to an integer, or
** returns 0 if float is not within the range of a lua_Integer.
** (The range comparisons are tricky because of rounding. The tests
** here assume a two-complement representation, where MININTEGER always
** has an exact representation as a float; MAXINTEGER may not have one,
** and therefore its conversion to float may have an ill-defined value.)
*/
#define lua_numbertointeger(n,p) \
((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
(n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
(*(p) = (LUA_INTEGER)(n), 1))
/* now the variable definitions */
#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */
#define LUA_NUMBER float
#define luai_l_mathlim(n) (FLT_##n)
#define LUAI_UACNUMBER double
#define LUA_NUMBER_FRMLEN ""
#define LUA_NUMBER_FMT "%.7g"
#define luai_l_mathop(op) op##f
#define lua_str2number(s,p) strtof((s), (p))
#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */
#define LUA_NUMBER long double
#define luai_l_mathlim(n) (LDBL_##n)
#define LUAI_UACNUMBER long double
#define LUA_NUMBER_FRMLEN "L"
#define LUA_NUMBER_FMT "%.19Lg"
#define luai_l_mathop(op) op##l
#define lua_str2number(s,p) strtold((s), (p))
#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */
#define LUA_NUMBER double
#define luai_l_mathlim(n) (DBL_##n)
#define LUAI_UACNUMBER double
#define LUA_NUMBER_FRMLEN ""
#define LUA_NUMBER_FMT "%.14g"
#define luai_l_mathop(op) op
#define lua_str2number(s,p) strtod((s), (p))
#else /* }{ */
#error "numeric float type not defined"
#endif /* } */
/*
@@ LUA_INTEGER is the integer type used by Lua.
**
@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
**
@@ LUAI_UACINT is the result of a 'default argument promotion'
@@ over a lUA_INTEGER.
@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
@@ LUA_INTEGER_FMT is the format for writing integers.
@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
@@ lua_integer2str converts an integer to a string.
*/
/* The following definitions are good for most cases here */
#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d"
#define LUAI_UACINT LUA_INTEGER
#define lua_integer2str(s,sz,n) \
luai_l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n))
/*
** use LUAI_UACINT here to avoid problems with promotions (which
** can turn a comparison between unsigneds into a signed comparison)
*/
#define LUA_UNSIGNED unsigned LUAI_UACINT
/* now the variable definitions */
#if LUA_INT_TYPE == LUA_INT_INT /* { int */
#define LUA_INTEGER int
#define LUA_INTEGER_FRMLEN ""
#define LUA_MAXINTEGER INT_MAX
#define LUA_MININTEGER INT_MIN
#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */
#define LUA_INTEGER long
#define LUA_INTEGER_FRMLEN "l"
#define LUA_MAXINTEGER LONG_MAX
#define LUA_MININTEGER LONG_MIN
#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */
/* use presence of macro LLONG_MAX as proxy for C99 compliance */
#if defined(LLONG_MAX) /* { */
/* use ISO C99 stuff */
#define LUA_INTEGER long long
#define LUA_INTEGER_FRMLEN "ll"
#define LUA_MAXINTEGER LLONG_MAX
#define LUA_MININTEGER LLONG_MIN
#elif defined(LUA_USE_WINDOWS) /* }{ */
/* in Windows, can use specific Windows types */
#define LUA_INTEGER __int64
#define LUA_INTEGER_FRMLEN "I64"
#define LUA_MAXINTEGER _I64_MAX
#define LUA_MININTEGER _I64_MIN
#else /* }{ */
#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \
or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)"
#endif /* } */
#else /* }{ */
#error "numeric integer type not defined"
#endif /* } */
/* }================================================================== */
/*
** {==================================================================
** Dependencies with C99 and other C details
** ===================================================================
*/
/*
@@ luai_l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
** (All uses in Lua have only one format item.)
*/
#if !defined(LUA_USE_C89)
#define luai_l_sprintf(s,sz,f,i) snprintf(s,sz,f,i)
#else
#define luai_l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i))
#endif
/*
@@ lua_strx2number converts an hexadecimal numeric string to a number.
** In C99, 'strtod' does that conversion. Otherwise, you can
** leave 'lua_strx2number' undefined and Lua will provide its own
** implementation.
*/
#if !defined(LUA_USE_C89)
#define lua_strx2number(s,p) lua_str2number(s,p)
#endif
/*
@@ lua_number2strx converts a float to an hexadecimal numeric string.
** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
** provide its own implementation.
*/
#if !defined(LUA_USE_C89)
#define lua_number2strx(L,b,sz,f,n) \
((void)L, luai_l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n)))
#endif
/*
** 'strtof' and 'opf' variants for math functions are not valid in
** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the
** availability of these variants. ('math.h' is already included in
** all files that use these macros.)
*/
#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF))
#undef luai_l_mathop /* variants not available */
#undef lua_str2number
#define luai_l_mathop(op) (lua_Number)op /* no variant */
#define lua_str2number(s,p) ((lua_Number)strtod((s), (p)))
#endif
/*
@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation
** functions. It must be a numerical type; Lua will use 'intptr_t' if
** available, otherwise it will use 'ptrdiff_t' (the nearest thing to
** 'intptr_t' in C89)
*/
#define LUA_KCONTEXT ptrdiff_t
#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
__STDC_VERSION__ >= 199901L
#include <stdint.h>
#if defined(INTPTR_MAX) /* even in C99 this type is optional */
#undef LUA_KCONTEXT
#define LUA_KCONTEXT intptr_t
#endif
#endif
/*
@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point).
** Change that if you do not want to use C locales. (Code using this
** macro must include header 'locale.h'.)
*/
#if !defined(lua_getlocaledecpoint)
#define lua_getlocaledecpoint() (localeconv()->decimal_point[0])
#endif
/* }================================================================== */
/*
** {==================================================================
** Language Variations
** =====================================================================
*/
/*
@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some
** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from
** numbers to strings. Define LUA_NOCVTS2N to turn off automatic
** coercion from strings to numbers.
*/
/* #define LUA_NOCVTN2S */
/* #define LUA_NOCVTS2N */
/*
@@ LUA_USE_APICHECK turns on several consistency checks on the C API.
** Define it as a help when debugging C code.
*/
#if defined(LUA_USE_APICHECK)
#include <assert.h>
#define luai_apicheck(l,e) assert(e)
#endif
/* }================================================================== */
/*
** {==================================================================
** Macros that affect the API and must be stable (that is, must be the
** same when you compile Lua and when you compile code that links to
** Lua). You probably do not want/need to change them.
** =====================================================================
*/
/*
@@ LUAI_MAXSTACK limits the size of the Lua stack.
** CHANGE it if you need a different limit. This limit is arbitrary;
** its only purpose is to stop Lua from consuming unlimited stack
** space (and to reserve some numbers for pseudo-indices).
*/
#if LUAI_BITSINT >= 32
#define LUAI_MAXSTACK 1000000
#else
#define LUAI_MAXSTACK 15000
#endif
/*
@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
** a Lua state with very fast access.
** CHANGE it if you need a different size.
*/
#define LUA_EXTRASPACE (sizeof(void *))
/*
@@ LUA_IDSIZE gives the maximum size for the description of the source
@@ of a function in debug information.
** CHANGE it if you want a different size.
*/
#define LUA_IDSIZE 60
/*
@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
** CHANGE it if it uses too much C-stack space. (For long double,
** 'string.format("%.99f", -1e4932)' needs 5034 bytes, so a
** smaller buffer would force a memory allocation for each call to
** 'string.format'.)
*/
#if LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE
#define LUAL_BUFFERSIZE 8192
#else
#define LUAL_BUFFERSIZE ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer)))
#endif
/* }================================================================== */
/*
@@ LUA_QL describes how error messages quote program elements.
** Lua does not use these macros anymore; they are here for
** compatibility only.
*/
#define LUA_QL(x) "'" x "'"
#define LUA_QS LUA_QL("%s")
/* =================================================================== */
/*
** Local configuration. You can use this space to add your redefinitions
** without modifying the main part of the file.
*/
/*__lua.h__*/
#define LUA_VERSION_MAJOR "5"
#define LUA_VERSION_MINOR "3"
#define LUA_VERSION_NUM 503
#define LUA_VERSION_RELEASE "4"
#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE
#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2017 Lua.org, PUC-Rio"
#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
/* mark for precompiled code ('<esc>Lua') */
#define LUA_SIGNATURE "\x1bLua"
/* option for multiple returns in 'lua_pcall' and 'lua_call' */
#define LUA_MULTRET (-1)
/*
** Pseudo-indices
** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty
** space after that to help overflow detection)
*/
#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000)
#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i))
/* thread status */
#define LUA_OK 0
#define LUA_YIELD 1
#define LUA_ERRRUN 2
#define LUA_ERRSYNTAX 3
#define LUA_ERRMEM 4
#define LUA_ERRGCMM 5
#define LUA_ERRERR 6
typedef struct lua_State lua_State;
/*
** basic types
*/
#define LUA_TNONE (-1)
#define LUA_TNIL 0
#define LUA_TBOOLEAN 1
#define LUA_TLIGHTUSERDATA 2
#define LUA_TNUMBER 3
#define LUA_TSTRING 4
#define LUA_TTABLE 5
#define LUA_TFUNCTION 6
#define LUA_TUSERDATA 7
#define LUA_TTHREAD 8
#define LUA_NUMTAGS 9
/* minimum Lua stack available to a C function */
#define LUA_MINSTACK 20
/* predefined values in the registry */
#define LUA_RIDX_MAINTHREAD 1
#define LUA_RIDX_GLOBALS 2
#define LUA_RIDX_LAST LUA_RIDX_GLOBALS
/* type of numbers in Lua */
typedef LUA_NUMBER lua_Number;
/* type for integer functions */
typedef LUA_INTEGER lua_Integer;
/* unsigned integer type */
typedef LUA_UNSIGNED lua_Unsigned;
/* type for continuation-function contexts */
typedef LUA_KCONTEXT lua_KContext;
/*
** Type for C functions registered with Lua
*/
typedef int (*lua_CFunction) (lua_State *L);
/*
** Type for continuation functions
*/
typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
/*
** Type for functions that read/write blocks when loading/dumping Lua chunks
*/
typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud);
/*
** Type for memory-allocation functions
*/
typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
/*
** generic extra include file
*/
#if defined(LUA_USER_H)
#include LUA_USER_H
#endif
/*
** RCS ident string
*/
extern const char lua_ident[];
/*
** state manipulation
*/
LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
LUA_API void (lua_close) (lua_State *L);
LUA_API lua_State *(lua_newthread) (lua_State *L);
LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
LUA_API const lua_Number *(lua_version) (lua_State *L);
/*
** basic stack manipulation
*/
LUA_API int (lua_absindex) (lua_State *L, int idx);
LUA_API int (lua_gettop) (lua_State *L);
LUA_API void (lua_settop) (lua_State *L, int idx);
LUA_API void (lua_pushvalue) (lua_State *L, int idx);
LUA_API void (lua_rotate) (lua_State *L, int idx, int n);
LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx);
LUA_API int (lua_checkstack) (lua_State *L, int n);
LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n);
/*
** access functions (stack -> C)
*/
LUA_API int (lua_isnumber) (lua_State *L, int idx);
LUA_API int (lua_isstring) (lua_State *L, int idx);
LUA_API int (lua_iscfunction) (lua_State *L, int idx);
LUA_API int (lua_isinteger) (lua_State *L, int idx);
LUA_API int (lua_isuserdata) (lua_State *L, int idx);
LUA_API int (lua_type) (lua_State *L, int idx);
LUA_API const char *(lua_typename) (lua_State *L, int tp);
LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum);
LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum);
LUA_API int (lua_toboolean) (lua_State *L, int idx);
LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len);
LUA_API size_t (lua_rawlen) (lua_State *L, int idx);
LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx);
LUA_API void *(lua_touserdata) (lua_State *L, int idx);
LUA_API lua_State *(lua_tothread) (lua_State *L, int idx);
LUA_API const void *(lua_topointer) (lua_State *L, int idx);
/*
** Comparison and arithmetic functions
*/
#define LUA_OPADD 0 /* ORDER TM, ORDER OP */
#define LUA_OPSUB 1
#define LUA_OPMUL 2
#define LUA_OPMOD 3
#define LUA_OPPOW 4
#define LUA_OPDIV 5
#define LUA_OPIDIV 6
#define LUA_OPBAND 7
#define LUA_OPBOR 8
#define LUA_OPBXOR 9
#define LUA_OPSHL 10
#define LUA_OPSHR 11
#define LUA_OPUNM 12
#define LUA_OPBNOT 13
LUA_API void (lua_arith) (lua_State *L, int op);
#define LUA_OPEQ 0
#define LUA_OPLT 1
#define LUA_OPLE 2
LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2);
LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op);
/*
** push functions (C -> stack)
*/
LUA_API void (lua_pushnil) (lua_State *L);
LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n);
LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n);
LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len);
LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
va_list argp);
LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
LUA_API void (lua_pushboolean) (lua_State *L, int b);
LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p);
LUA_API int (lua_pushthread) (lua_State *L);
/*
** get functions (Lua -> stack)
*/
LUA_API int (lua_getglobal) (lua_State *L, const char *name);
LUA_API int (lua_gettable) (lua_State *L, int idx);
LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);
LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n);
LUA_API int (lua_rawget) (lua_State *L, int idx);
LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec);
LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
LUA_API int (lua_getmetatable) (lua_State *L, int objindex);
LUA_API int (lua_getuservalue) (lua_State *L, int idx);
/*
** set functions (stack -> Lua)
*/
LUA_API void (lua_setglobal) (lua_State *L, const char *name);
LUA_API void (lua_settable) (lua_State *L, int idx);
LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k);
LUA_API void (lua_seti) (lua_State *L, int idx, lua_Integer n);
LUA_API void (lua_rawset) (lua_State *L, int idx);
LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer n);
LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p);
LUA_API int (lua_setmetatable) (lua_State *L, int objindex);
LUA_API void (lua_setuservalue) (lua_State *L, int idx);
/*
** 'load' and 'call' functions (load and run Lua code)
*/
LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults,
lua_KContext ctx, lua_KFunction k);
#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL)
LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
lua_KContext ctx, lua_KFunction k);
#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL)
LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt,
const char *chunkname, const char *mode);
LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
/*
** coroutine functions
*/
LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx,
lua_KFunction k);
LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg);
LUA_API int (lua_status) (lua_State *L);
LUA_API int (lua_isyieldable) (lua_State *L);
#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL)
/*
** garbage-collection function and options
*/
#define LUA_GCSTOP 0
#define LUA_GCRESTART 1
#define LUA_GCCOLLECT 2
#define LUA_GCCOUNT 3
#define LUA_GCCOUNTB 4
#define LUA_GCSTEP 5
#define LUA_GCSETPAUSE 6
#define LUA_GCSETSTEPMUL 7
#define LUA_GCISRUNNING 9
LUA_API int (lua_gc) (lua_State *L, int what, int data);
/*
** miscellaneous functions
*/
LUA_API int (lua_error) (lua_State *L);
LUA_API int (lua_next) (lua_State *L, int idx);
LUA_API void (lua_concat) (lua_State *L, int n);
LUA_API void (lua_len) (lua_State *L, int idx);
LUA_API size_t (lua_stringtonumber) (lua_State *L, const char *s);
LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
/*
** {==============================================================
** some useful macros
** ===============================================================
*/
#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE))
#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL)
#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL)
#define lua_pop(L,n) lua_settop(L, -(n)-1)
#define lua_newtable(L) lua_createtable(L, 0, 0)
#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0)
#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION)
#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE)
#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL)
#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN)
#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD)
#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE)
#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0)
#define lua_pushliteral(L, s) lua_pushstring(L, "" s)
#define lua_pushglobaltable(L) \
((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
#define lua_tostring(L,i) lua_tolstring(L, (i), NULL)
#define lua_insert(L,idx) lua_rotate(L, (idx), 1)
#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1))
#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1))
/* }============================================================== */
/*
** {==============================================================
** compatibility macros for unsigned conversions
** ===============================================================
*/
#if defined(LUA_COMPAT_APIINTCASTS)
#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n))
#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is))
#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL)
#endif
/* }============================================================== */
/*
** {======================================================================
** Debug API
** =======================================================================
*/
/*
** Event codes
*/
#define LUA_HOOKCALL 0
#define LUA_HOOKRET 1
#define LUA_HOOKLINE 2
#define LUA_HOOKCOUNT 3
#define LUA_HOOKTAILCALL 4
/*
** Event luai_masks
*/
#define LUA_MASKCALL (1 << LUA_HOOKCALL)
#define LUA_MASKRET (1 << LUA_HOOKRET)
#define LUA_MASKLINE (1 << LUA_HOOKLINE)
#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT)
typedef struct lua_Debug lua_Debug; /* activation record */
/* Functions to be called by the debugger in specific events */
typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);
LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);
LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
int fidx2, int n2);
LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
LUA_API lua_Hook (lua_gethook) (lua_State *L);
LUA_API int (lua_gethookmask) (lua_State *L);
LUA_API int (lua_gethookcount) (lua_State *L);
struct lua_Debug {
int event;
const char *name; /* (n) */
const char *namewhat; /* (n) 'global', 'local', 'luai_field', 'method' */
const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */
const char *source; /* (S) */
int luai_currentline; /* (l) */
int linedefined; /* (S) */
int lastlinedefined; /* (S) */
unsigned char nups; /* (u) number of upvalues */
unsigned char nparams;/* (u) number of parameters */
char isvararg; /* (u) */
char istailcall; /* (t) */
char short_src[LUA_IDSIZE]; /* (S) */
/* private part */
struct luai_CallInfo *i_ci; /* active function */
};
/*__lauxlib.h__*/
/* extra error code for 'luaL_loadfilex' */
#define LUA_ERRFILE (LUA_ERRERR+1)
/* key, in the registry, for table of loaded modules */
#define LUA_LOADED_TABLE "_LOADED"
/* key, in the registry, for table of preloaded loaders */
#define LUA_PRELOAD_TABLE "_PRELOAD"
typedef struct luaL_Reg {
const char *name;
lua_CFunction func;
} luaL_Reg;
#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number))
LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
#define luaL_checkversion(L) \
luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
size_t *l);
LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
const char *def, size_t *l);
LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
lua_Integer def);
LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname);
LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname);
LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
LUALIB_API void (luaL_where) (lua_State *L, int lvl);
LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,
const char *const lst[]);
LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
/* predefined references */
#define LUA_NOREF (-2)
#define LUA_REFNIL (-1)
LUALIB_API int (luaL_ref) (lua_State *L, int t);
LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
const char *mode);
#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL)
LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
const char *name, const char *mode);
LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
LUALIB_API lua_State *(luaL_newstate) (void);
LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
const char *r);
LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
const char *msg, int level);
LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
lua_CFunction openf, int glb);
/*
** ===============================================================
** some useful macros
** ===============================================================
*/
#define luaL_newlibtable(L,l) \
lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
#define luaL_newlib(L,l) \
(luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
#define luaL_argcheck(L, luai_cond,arg,extramsg) \
((void)((luai_cond) || luaL_argerror(L, (arg), (extramsg))))
#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))
#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))
#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i)))
#define luaL_dofile(L, fn) \
(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
#define luaL_dostring(L, s) \
(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))
#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL)
/*
** {======================================================
** Generic Buffer manipulation
** =======================================================
*/
typedef struct luaL_Buffer {
char *b; /* buffer address */
size_t size; /* buffer size */
size_t n; /* number of characters in buffer */
lua_State *L;
char initb[LUAL_BUFFERSIZE]; /* initial buffer */
} luaL_Buffer;
#define luaL_addchar(B,c) \
((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
((B)->b[(B)->n++] = (c)))
#define luaL_addsize(B,s) ((B)->n += (s))
LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
/* }====================================================== */
/*
** {======================================================
** File handles for IO library
** =======================================================
*/
/*
** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
** initial structure 'luaL_Stream' (it may contain other fields
** after that initial structure).
*/
#define LUA_FILEHANDLE "FILE*"
typedef struct luaL_Stream {
FILE *f; /* stream (NULL for incompletely created streams) */
lua_CFunction closef; /* to close stream (NULL for closed streams) */
} luaL_Stream;
/* }====================================================== */
/* compatibility with old module system */
#if defined(LUA_COMPAT_MODULE)
LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
int sizehint);
LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
const luaL_Reg *l, int nup);
#define luaL_register(L,n,l) (luaL_openlib(L,(n),(l),0))
#endif
/*
** {==================================================================
** "Abstraction Layer" for basic report of messages and errors
** ===================================================================
*/
/* print a string */
#if !defined(lua_writestring)
#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout)
#endif
/* print a newline and flush the output */
#if !defined(lua_writeline)
#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout))
#endif
/* print an error message */
#if !defined(lua_writestringerror)
#define lua_writestringerror(s,p) \
(fprintf(stderr, (s), (p)), fflush(stderr))
#endif
/* }================================================================== */
/*
** {============================================================
** Compatibility with deprecated conversions
** =============================================================
*/
#if defined(LUA_COMPAT_APIINTCASTS)
#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a))
#define luaL_optunsigned(L,a,d) \
((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))
#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d)))
#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n)))
#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d)))
#endif
/* }============================================================ */
/*__lualib.h__*/
/* version suffix for environment variable names */
#define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
LUAMOD_API int (luaopen_base) (lua_State *L);
#define LUA_COLIBNAME "coroutine"
LUAMOD_API int (luaopen_coroutine) (lua_State *L);
#define LUA_TABLIBNAME "table"
LUAMOD_API int (luaopen_table) (lua_State *L);
#define LUA_IOLIBNAME "io"
LUAMOD_API int (luaopen_io) (lua_State *L);
#define LUA_OSLIBNAME "os"
LUAMOD_API int (luaopen_os) (lua_State *L);
#define LUA_STRLIBNAME "string"
LUAMOD_API int (luaopen_string) (lua_State *L);
#define LUA_UTF8LIBNAME "utf8"
LUAMOD_API int (luaopen_utf8) (lua_State *L);
#define LUA_BITLIBNAME "bit32"
LUAMOD_API int (luaopen_bit32) (lua_State *L);
#define LUA_MATHLIBNAME "math"
LUAMOD_API int (luaopen_math) (lua_State *L);
#define LUA_DBLIBNAME "debug"
LUAMOD_API int (luaopen_debug) (lua_State *L);
#define LUA_LOADLIBNAME "package"
LUAMOD_API int (luaopen_package) (lua_State *L);
/* open all previous libraries */
LUALIB_API void (luaL_openlibs) (lua_State *L);
#if !defined(lua_assert)
#define lua_assert(x) ((void)0)
#endif
#endif // lua_h
/***************************************************************************
* IMPLEMENTATION
**************************************************************************/
#ifdef LUA_IMPLEMENTATION
#include <ctype.h>
#include <errno.h>
#include <float.h>
#include <locale.h>
#include <math.h>
#include <setjmp.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
/*__llimits.h__*/
/*
** 'luai_lu_mem' and 'luai_l_mem' are unsigned/signed integers big enough to count
** the total memory used by Lua (in bytes). Usually, 'size_t' and
** 'ptrdiff_t' should work, but we use 'long' for 16-bit machines.
*/
#if defined(LUAI_MEM) /* { external definitions? */
typedef LUAI_UMEM luai_lu_mem;
typedef LUAI_MEM luai_l_mem;
#elif LUAI_BITSINT >= 32 /* }{ */
typedef size_t luai_lu_mem;
typedef ptrdiff_t luai_l_mem;
#else /* 16-bit ints */ /* }{ */
typedef unsigned long luai_lu_mem;
typedef long luai_l_mem;
#endif /* } */
/* chars used as small naturals (so that 'char' is reserved for characters) */
typedef unsigned char luai_lu_byte;
/* maximum value for size_t */
#define LUAI_MAX_SIZET ((size_t)(~(size_t)0))
/* maximum size visible for Lua (must be representable in a lua_Integer */
#define LUAI_MAX_SIZE (sizeof(size_t) < sizeof(lua_Integer) ? LUAI_MAX_SIZET \
: (size_t)(LUA_MAXINTEGER))
#define LUAI_MAX_LUMEM ((luai_lu_mem)(~(luai_lu_mem)0))
#define LUAI_MAX_LMEM ((luai_l_mem)(LUAI_MAX_LUMEM >> 1))
#define LUAI_MAX_INT INT_MAX /* maximum value of an int */
/*
** conversion of pointer to unsigned integer:
** this is for hashing only; there is no problem if the integer
** cannot hold the whole pointer value
*/
#define luai_point2uint(p) ((unsigned int)((size_t)(p) & UINT_MAX))
/* type to ensure maximum alignment */
#if defined(LUAI_USER_ALIGNMENT_T)
typedef LUAI_USER_ALIGNMENT_T LUAI_L_Umaxalign;
#else
typedef union {
lua_Number n;
double u;
void *s;
lua_Integer i;
long l;
} LUAI_L_Umaxalign;
#endif
/* types of 'usual argument conversions' for lua_Number and lua_Integer */
typedef LUAI_UACNUMBER luai_l_uacNumber;
typedef LUAI_UACINT luai_l_uacInt;
/* internal assertions for in-house debugging */
#if defined(lua_assert)
#define luai_check_exp(c,e) (lua_assert(c), (e))
/* to avoid problems with conditions too long */
#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0))
#else
#define lua_assert(c) ((void)0)
#define luai_check_exp(c,e) (e)
#define lua_longassert(c) ((void)0)
#endif
/*
** assertion for checking API calls
*/
#if !defined(luai_apicheck)
#define luai_apicheck(l,e) lua_assert(e)
#endif
#define luai_api_check(l,e,msg) luai_apicheck(l,(e) && msg)
/* macro to avoid warnings about unused variables */
#if !defined(LUAI_UNUSED)
#define LUAI_UNUSED(x) ((void)(x))
#endif
/* type casts (a macro highlights casts in the code) */
#define luai_cast(t, exp) ((t)(exp))
#define luai_cast_void(i) luai_cast(void, (i))
#define luai_cast_byte(i) luai_cast(luai_lu_byte, (i))
#define luai_cast_num(i) luai_cast(lua_Number, (i))
#define luai_cast_int(i) luai_cast(int, (i))
#define luai_cast_uchar(i) luai_cast(unsigned char, (i))
/* luai_cast a signed lua_Integer to lua_Unsigned */
#if !defined(luai_l_castS2U)
#define luai_l_castS2U(i) ((lua_Unsigned)(i))
#endif
/*
** luai_cast a lua_Unsigned to a signed lua_Integer; this luai_cast is
** not strict ISO C, but two-complement architectures should
** work fine.
*/
#if !defined(luai_l_castU2S)
#define luai_l_castU2S(i) ((lua_Integer)(i))
#endif
/*
** non-return type
*/
#if defined(__GNUC__)
#define luai_l_noret void __attribute__((noreturn))
#elif defined(_MSC_VER) && _MSC_VER >= 1200
#define luai_l_noret void __declspec(noreturn)
#else
#define luai_l_noret void
#endif
/*
** maximum depth for nested C calls and syntactical nested non-terminals
** in a program. (Value must fit in an unsigned short int.)
*/
#if !defined(LUAI_MAXCCALLS)
#define LUAI_MAXCCALLS 200
#endif
/*
** type for virtual-machine instructions;
** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
*/
#if LUAI_BITSINT >= 32
typedef unsigned int Instruction;
#else
typedef unsigned long Instruction;
#endif
/*
** Maximum length for short strings, that is, strings that are
** internalized. (Cannot be smaller than reserved words or tags for
** metamethods, as these strings must be internalized;
** #("function") = 8, #("__newindex") = 10.)
*/
#if !defined(LUAI_MAXSHORTLEN)
#define LUAI_MAXSHORTLEN 40
#endif
/*
** Initial size for the string table (must be power of 2).
** The Lua core alone registers ~50 strings (reserved words +
** metaevent keys + a few others). Libraries would typically add
** a few dozens more.
*/
#if !defined(LUAI_MINSTRTABSIZE)
#define LUAI_MINSTRTABSIZE 128
#endif
/*
** Size of cache for strings in the API. 'N' is the number of
** sets (better be a prime) and "M" is the size of each set (M == 1
** makes a direct cache.)
*/
#if !defined(LUAI_STRCACHE_N)
#define LUAI_STRCACHE_N 53
#define LUAI_STRCACHE_M 2
#endif
/* minimum size for string buffer */
#if !defined(LUA_MINBUFFER)
#define LUA_MINBUFFER 32
#endif
/*
** macros that are executed whenever program enters the Lua core
** ('lua_lock') and leaves the core ('lua_unlock')
*/
#if !defined(lua_lock)
#define lua_lock(L) ((void) 0)
#define lua_unlock(L) ((void) 0)
#endif
/*
** macro executed during Lua functions at points where the
** function can yield.
*/
#if !defined(luai_threadyield)
#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);}
#endif
/*
** these macros allow user-specific actions on threads when you defined
** LUAI_EXTRASPACE and need to do something extra when a thread is
** created/deleted/resumed/yielded.
*/
#if !defined(luai_userstateopen)
#define luai_userstateopen(L) ((void)L)
#endif
#if !defined(luai_userstateclose)
#define luai_userstateclose(L) ((void)L)
#endif
#if !defined(luai_userstatethread)
#define luai_userstatethread(L,L1) ((void)L)
#endif
#if !defined(luai_userstatefree)
#define luai_userstatefree(L,L1) ((void)L)
#endif
#if !defined(luai_userstateresume)
#define luai_userstateresume(L,n) ((void)L)
#endif
#if !defined(luai_userstateyield)
#define luai_userstateyield(L,n) ((void)L)
#endif
/*
** The luai_num* macros define the primitive operations over numbers.
*/
/* floor division (defined as 'floor(a/b)') */
#if !defined(luai_numidiv)
#define luai_numidiv(L,a,b) ((void)L, luai_l_floor(luai_numdiv(L,a,b)))
#endif
/* float division */
#if !defined(luai_numdiv)
#define luai_numdiv(L,a,b) ((a)/(b))
#endif
/*
** modulo: defined as 'a - floor(a/b)*b'; this definition gives NaN when
** 'b' is huge, but the result should be 'a'. 'fmod' gives the result of
** 'a - trunc(a/b)*b', and therefore must be corrected when 'trunc(a/b)
** ~= floor(a/b)'. That happens when the division has a non-integer
** negative result, which is equivalent to the test below.
*/
#if !defined(luai_nummod)
#define luai_nummod(L,a,b,m) \
{ (m) = luai_l_mathop(fmod)(a,b); if ((m)*(b) < 0) (m) += (b); }
#endif
/* exponentiation */
#if !defined(luai_numpow)
#define luai_numpow(L,a,b) ((void)L, luai_l_mathop(pow)(a,b))
#endif
/* the others are quite standard operations */
#if !defined(luai_numadd)
#define luai_numadd(L,a,b) ((a)+(b))
#define luai_numsub(L,a,b) ((a)-(b))
#define luai_nummul(L,a,b) ((a)*(b))
#define luai_numunm(L,a) (-(a))
#define luai_numeq(a,b) ((a)==(b))
#define luai_numlt(a,b) ((a)<(b))
#define luai_numle(a,b) ((a)<=(b))
#define luai_numisnan(a) (!luai_numeq((a), (a)))
#endif
/*
** macro to control inclusion of some hard tests on stack reallocation
*/
#if !defined(LUAI_HARDSTACKTESTS)
#define luai_condmovestack(L,pre,pos) ((void)0)
#else
/* realloc stack keeping its size */
#define luai_condmovestack(L,pre,pos) \
{ int sz_ = (L)->stacksize; pre; luaD_reallocstack((L), sz_); pos; }
#endif
#if !defined(HARDMEMTESTS)
#define luai_condchangemem(L,pre,pos) ((void)0)
#else
#define luai_condchangemem(L,pre,pos) \
{ if (LUAI_G(L)->gcrunning) { pre; luaC_fullgc(L, 0); pos; } }
#endif
/*__lobject.h__*/
/*
** Extra tags for non-values
*/
#define LUA_TPROTO LUA_NUMTAGS /* function prototypes */
#define LUA_TDEADKEY (LUA_NUMTAGS+1) /* removed keys in tables */
/*
** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
*/
#define LUA_TOTALTAGS (LUA_TPROTO + 2)
/*
** tags for Tagged Values have the following use of bits:
** bits 0-3: actual tag (a LUA_T* value)
** bits 4-5: variant bits
** bit 6: whether value is collectable
*/
/*
** LUA_TFUNCTION variants:
** 0 - Lua function
** 1 - light C function
** 2 - regular C function (closure)
*/
/* Variant tags for functions */
#define LUA_TLCL (LUA_TFUNCTION | (0 << 4)) /* Lua closure */
#define LUA_TLCF (LUA_TFUNCTION | (1 << 4)) /* light C function */
#define LUA_TCCL (LUA_TFUNCTION | (2 << 4)) /* C closure */
/* Variant tags for strings */
#define LUA_TSHRSTR (LUA_TSTRING | (0 << 4)) /* short strings */
#define LUA_TLNGSTR (LUA_TSTRING | (1 << 4)) /* long strings */
/* Variant tags for numbers */
#define LUA_TNUMFLT (LUA_TNUMBER | (0 << 4)) /* float numbers */
#define LUA_TNUMINT (LUA_TNUMBER | (1 << 4)) /* integer numbers */
/* Bit mark for collectable types */
#define LUAI_BIT_ISCOLLECTABLE (1 << 6)
/* mark a tag as collectable */
#define luai_ctb(t) ((t) | LUAI_BIT_ISCOLLECTABLE)
/*
** Common type for all collectable objects
*/
typedef struct LUAI_GCObject LUAI_GCObject;
/*
** Common luai_Header for all collectable objects (in macro form, to be
** included in other objects)
*/
#define luai_CommonHeader LUAI_GCObject *luai_next; luai_lu_byte tt; luai_lu_byte marked
/*
** Common type has only the common header
*/
struct LUAI_GCObject {
luai_CommonHeader;
};
/*
** Tagged Values. This is the basic representation of values in Lua,
** an actual value plus a tag with its type.
*/
/*
** Union of all Lua values
*/
typedef union lua_Value {
LUAI_GCObject *gc; /* collectable objects */
void *p; /* light userdata */
int b; /* booleans */
lua_CFunction f; /* light C functions */
lua_Integer i; /* integer numbers */
lua_Number n; /* float numbers */
} lua_Value;
#define luai_TValuefields lua_Value value_; int tt_
typedef struct lua_TValue {
luai_TValuefields;
} luai_TValue;
/* macro defining a nil value */
#define LUAI_NILCONSTANT {NULL}, LUA_TNIL
#define luai_val_(o) ((o)->value_)
/* raw type tag of a luai_TValue */
#define luai_rttype(o) ((o)->tt_)
/* tag with no variants (bits 0-3) */
#define luai_novariant(x) ((x) & 0x0F)
/* type tag of a luai_TValue (bits 0-3 for tags + variant bits 4-5) */
#define luai_ttype(o) (luai_rttype(o) & 0x3F)
/* type tag of a luai_TValue with no variants (bits 0-3) */
#define luai_ttnov(o) (luai_novariant(luai_rttype(o)))
/* Macros to test type */
#define luai_checktag(o,t) (luai_rttype(o) == (t))
#define luai_checktype(o,t) (luai_ttnov(o) == (t))
#define luai_ttisnumber(o) luai_checktype((o), LUA_TNUMBER)
#define luai_ttisfloat(o) luai_checktag((o), LUA_TNUMFLT)
#define luai_ttisinteger(o) luai_checktag((o), LUA_TNUMINT)
#define luai_ttisnil(o) luai_checktag((o), LUA_TNIL)
#define luai_ttisboolean(o) luai_checktag((o), LUA_TBOOLEAN)
#define luai_ttislightuserdata(o) luai_checktag((o), LUA_TLIGHTUSERDATA)
#define luai_ttisstring(o) luai_checktype((o), LUA_TSTRING)
#define luai_ttisshrstring(o) luai_checktag((o), luai_ctb(LUA_TSHRSTR))
#define luai_ttislngstring(o) luai_checktag((o), luai_ctb(LUA_TLNGSTR))
#define luai_ttistable(o) luai_checktag((o), luai_ctb(LUA_TTABLE))
#define luai_ttisfunction(o) luai_checktype(o, LUA_TFUNCTION)
#define luai_ttisclosure(o) ((luai_rttype(o) & 0x1F) == LUA_TFUNCTION)
#define luai_ttisCclosure(o) luai_checktag((o), luai_ctb(LUA_TCCL))
#define luai_ttisLclosure(o) luai_checktag((o), luai_ctb(LUA_TLCL))
#define luai_ttislcf(o) luai_checktag((o), LUA_TLCF)
#define luai_ttisfulluserdata(o) luai_checktag((o), luai_ctb(LUA_TUSERDATA))
#define luai_ttisthread(o) luai_checktag((o), luai_ctb(LUA_TTHREAD))
#define luai_ttisdeadkey(o) luai_checktag((o), LUA_TDEADKEY)
/* Macros to access values */
#define luai_ivalue(o) luai_check_exp(luai_ttisinteger(o), luai_val_(o).i)
#define luai_fltvalue(o) luai_check_exp(luai_ttisfloat(o), luai_val_(o).n)
#define luai_nvalue(o) luai_check_exp(luai_ttisnumber(o), \
(luai_ttisinteger(o) ? luai_cast_num(luai_ivalue(o)) : luai_fltvalue(o)))
#define luai_gcvalue(o) luai_check_exp(luai_iscollectable(o), luai_val_(o).gc)
#define luai_pvalue(o) luai_check_exp(luai_ttislightuserdata(o), luai_val_(o).p)
#define luai_tsvalue(o) luai_check_exp(luai_ttisstring(o), luai_gco2ts(luai_val_(o).gc))
#define luai_uvalue(o) luai_check_exp(luai_ttisfulluserdata(o), luai_gco2u(luai_val_(o).gc))
#define luai_clvalue(o) luai_check_exp(luai_ttisclosure(o), luai_gco2cl(luai_val_(o).gc))
#define luai_clLvalue(o) luai_check_exp(luai_ttisLclosure(o), luai_gco2lcl(luai_val_(o).gc))
#define luai_clCvalue(o) luai_check_exp(luai_ttisCclosure(o), luai_gco2ccl(luai_val_(o).gc))
#define luai_fvalue(o) luai_check_exp(luai_ttislcf(o), luai_val_(o).f)
#define luai_hvalue(o) luai_check_exp(luai_ttistable(o), luai_gco2t(luai_val_(o).gc))
#define luai_bvalue(o) luai_check_exp(luai_ttisboolean(o), luai_val_(o).b)
#define luai_thvalue(o) luai_check_exp(luai_ttisthread(o), luai_gco2th(luai_val_(o).gc))
/* a dead value may get the 'gc' luai_field, but cannot access its contents */
#define luai_deadvalue(o) luai_check_exp(luai_ttisdeadkey(o), luai_cast(void *, luai_val_(o).gc))
#define luai_l_isfalse(o) (luai_ttisnil(o) || (luai_ttisboolean(o) && luai_bvalue(o) == 0))
#define luai_iscollectable(o) (luai_rttype(o) & LUAI_BIT_ISCOLLECTABLE)
/* Macros for internal tests */
#define luai_righttt(obj) (luai_ttype(obj) == luai_gcvalue(obj)->tt)
#define luai_checkliveness(L,obj) \
lua_longassert(!luai_iscollectable(obj) || \
(luai_righttt(obj) && (L == NULL || !luai_isdead(LUAI_G(L),luai_gcvalue(obj)))))
/* Macros to set values */
#define luai_settt_(o,t) ((o)->tt_=(t))
#define luai_setfltvalue(obj,x) \
{ luai_TValue *io=(obj); luai_val_(io).n=(x); luai_settt_(io, LUA_TNUMFLT); }
#define luai_chgfltvalue(obj,x) \
{ luai_TValue *io=(obj); lua_assert(luai_ttisfloat(io)); luai_val_(io).n=(x); }
#define luai_setivalue(obj,x) \
{ luai_TValue *io=(obj); luai_val_(io).i=(x); luai_settt_(io, LUA_TNUMINT); }
#define luai_chgivalue(obj,x) \
{ luai_TValue *io=(obj); lua_assert(luai_ttisinteger(io)); luai_val_(io).i=(x); }
#define luai_setnilvalue(obj) luai_settt_(obj, LUA_TNIL)
#define luai_setfvalue(obj,x) \
{ luai_TValue *io=(obj); luai_val_(io).f=(x); luai_settt_(io, LUA_TLCF); }
#define luai_setpvalue(obj,x) \
{ luai_TValue *io=(obj); luai_val_(io).p=(x); luai_settt_(io, LUA_TLIGHTUSERDATA); }
#define luai_setbvalue(obj,x) \
{ luai_TValue *io=(obj); luai_val_(io).b=(x); luai_settt_(io, LUA_TBOOLEAN); }
#define luai_setgcovalue(L,obj,x) \
{ luai_TValue *io = (obj); LUAI_GCObject *i_g=(x); \
luai_val_(io).gc = i_g; luai_settt_(io, luai_ctb(i_g->tt)); }
#define luai_setsvalue(L,obj,x) \
{ luai_TValue *io = (obj); luai_TString *x_ = (x); \
luai_val_(io).gc = luai_obj2gco(x_); luai_settt_(io, luai_ctb(x_->tt)); \
luai_checkliveness(L,io); }
#define luai_setuvalue(L,obj,x) \
{ luai_TValue *io = (obj); luai_Udata *x_ = (x); \
luai_val_(io).gc = luai_obj2gco(x_); luai_settt_(io, luai_ctb(LUA_TUSERDATA)); \
luai_checkliveness(L,io); }
#define luai_setthvalue(L,obj,x) \
{ luai_TValue *io = (obj); lua_State *x_ = (x); \
luai_val_(io).gc = luai_obj2gco(x_); luai_settt_(io, luai_ctb(LUA_TTHREAD)); \
luai_checkliveness(L,io); }
#define luai_setclLvalue(L,obj,x) \
{ luai_TValue *io = (obj); luai_LClosure *x_ = (x); \
luai_val_(io).gc = luai_obj2gco(x_); luai_settt_(io, luai_ctb(LUA_TLCL)); \
luai_checkliveness(L,io); }
#define luai_setclCvalue(L,obj,x) \
{ luai_TValue *io = (obj); luai_CClosure *x_ = (x); \
luai_val_(io).gc = luai_obj2gco(x_); luai_settt_(io, luai_ctb(LUA_TCCL)); \
luai_checkliveness(L,io); }
#define luai_sethvalue(L,obj,x) \
{ luai_TValue *io = (obj); luai_Table *x_ = (x); \
luai_val_(io).gc = luai_obj2gco(x_); luai_settt_(io, luai_ctb(LUA_TTABLE)); \
luai_checkliveness(L,io); }
#define luai_setdeadvalue(obj) luai_settt_(obj, LUA_TDEADKEY)
#define luai_setobj(L,obj1,obj2) \
{ luai_TValue *io1=(obj1); *io1 = *(obj2); \
(void)L; luai_checkliveness(L,io1); }
/*
** different types of assignments, according to destination
*/
/* from stack to (same) stack */
#define luai_setobjs2s luai_setobj
/* to stack (not from same stack) */
#define luai_setobj2s luai_setobj
#define luai_setsvalue2s luai_setsvalue
#define luai_sethvalue2s luai_sethvalue
#define luai_setptvalue2s setptvalue
/* from table to same table */
#define luai_setobjt2t luai_setobj
/* to new object */
#define luai_setobj2n luai_setobj
#define luai_setsvalue2n luai_setsvalue
/* to table (define it as an expression to be used in macros) */
#define luai_setobj2t(L,o1,o2) ((void)L, *(o1)=*(o2), luai_checkliveness(L,(o1)))
/*
** {======================================================
** types and prototypes
** =======================================================
*/
typedef luai_TValue *luai_StkId; /* index to stack elements */
/*
** luai_Header for string value; string bytes follow the end of this structure
** (aligned according to 'luai_UTString'; see luai_next).
*/
typedef struct luai_TString {
luai_CommonHeader;
luai_lu_byte extra; /* reserved words for short strings; "has hash" for longs */
luai_lu_byte shrlen; /* length for short strings */
unsigned int hash;
union {
size_t lnglen; /* length for long strings */
struct luai_TString *hnext; /* linked list for hash table */
} u;
} luai_TString;
/*
** Ensures that address after this type is always fully aligned.
*/
typedef union luai_UTString {
LUAI_L_Umaxalign dummy; /* ensures maximum alignment for strings */
luai_TString tsv;
} luai_UTString;
/*
** Get the actual string (array of bytes) from a 'luai_TString'.
** (Access to 'extra' ensures that value is really a 'luai_TString'.)
*/
#define luai_getstr(ts) \
luai_check_exp(sizeof((ts)->extra), luai_cast(char *, (ts)) + sizeof(luai_UTString))
/* get the actual string (array of bytes) from a Lua value */
#define luai_svalue(o) luai_getstr(luai_tsvalue(o))
/* get string length from 'luai_TString *s' */
#define luai_tsslen(s) ((s)->tt == LUA_TSHRSTR ? (s)->shrlen : (s)->u.lnglen)
/* get string length from 'luai_TValue *o' */
#define luai_vslen(o) luai_tsslen(luai_tsvalue(o))
/*
** luai_Header for userdata; memory area follows the end of this structure
** (aligned according to 'luai_UUdata'; see luai_next).
*/
typedef struct luai_Udata {
luai_CommonHeader;
luai_lu_byte ttuv_; /* user value's tag */
struct luai_Table *metatable;
size_t len; /* number of bytes */
union lua_Value user_; /* user value */
} luai_Udata;
/*
** Ensures that address after this type is always fully aligned.
*/
typedef union luai_UUdata {
LUAI_L_Umaxalign dummy; /* ensures maximum alignment for 'local' udata */
luai_Udata uv;
} luai_UUdata;
/*
** Get the address of memory luai_getblock inside 'luai_Udata'.
** (Access to 'ttuv_' ensures that value is really a 'luai_Udata'.)
*/
#define luai_getudatamem(u) \
luai_check_exp(sizeof((u)->ttuv_), (luai_cast(char*, (u)) + sizeof(luai_UUdata)))
#define luai_setuservalue(L,u,o) \
{ const luai_TValue *io=(o); luai_Udata *iu = (u); \
iu->user_ = io->value_; iu->ttuv_ = luai_rttype(io); \
luai_checkliveness(L,io); }
#define luai_getuservalue(L,u,o) \
{ luai_TValue *io=(o); const luai_Udata *iu = (u); \
io->value_ = iu->user_; luai_settt_(io, iu->ttuv_); \
luai_checkliveness(L,io); }
/*
** Description of an upvalue for function prototypes
*/
typedef struct luai_Upvaldesc {
luai_TString *name; /* upvalue name (for debug information) */
luai_lu_byte instack; /* whether it is in stack (register) */
luai_lu_byte idx; /* index of upvalue (in stack or in outer function's list) */
} luai_Upvaldesc;
/*
** Description of a local variable for function prototypes
** (used for debug information)
*/
typedef struct luai_LocVar {
luai_TString *varname;
int startpc; /* first point where variable is active */
int endpc; /* first point where variable is dead */
} luai_LocVar;
/*
** Function Prototypes
*/
typedef struct luai_Proto {
luai_CommonHeader;
luai_lu_byte numparams; /* number of fixed parameters */
luai_lu_byte is_vararg;
luai_lu_byte maxstacksize; /* number of registers needed by this function */
int sizeupvalues; /* size of 'upvalues' */
int sizek; /* size of 'k' */
int sizecode;
int sizelineinfo;
int sizep; /* size of 'p' */
int sizelocvars;
int linedefined; /* debug information */
int lastlinedefined; /* debug information */
luai_TValue *k; /* constants used by the function */
Instruction *code; /* opcodes */
struct luai_Proto **p; /* functions defined inside the function */
int *lineinfo; /* map from opcodes to source lines (debug information) */
luai_LocVar *locvars; /* information about local variables (debug information) */
luai_Upvaldesc *upvalues; /* upvalue information */
struct luai_LClosure *cache; /* last-created closure with this prototype */
luai_TString *source; /* used for debug information */
LUAI_GCObject *gclist;
} luai_Proto;
/*
** Lua Upvalues
*/
typedef struct luai_UpVal luai_UpVal;
/*
** Closures
*/
#define luai_ClosureHeader \
luai_CommonHeader; luai_lu_byte nupvalues; LUAI_GCObject *gclist
typedef struct luai_CClosure {
luai_ClosureHeader;
lua_CFunction f;
luai_TValue upvalue[1]; /* list of upvalues */
} luai_CClosure;
typedef struct luai_LClosure {
luai_ClosureHeader;
struct luai_Proto *p;
luai_UpVal *upvals[1]; /* list of upvalues */
} luai_LClosure;
typedef union luai_Closure {
luai_CClosure c;
luai_LClosure l;
} luai_Closure;
#define luai_isLfunction(o) luai_ttisLclosure(o)
#define luai_getproto(o) (luai_clLvalue(o)->p)
/*
** Tables
*/
typedef union LUAI_TKey {
struct {
luai_TValuefields;
int luai_next; /* for chaining (offset for luai_next node) */
} nk;
luai_TValue tvk;
} LUAI_TKey;
/* copy a value into a key without messing up luai_field 'luai_next' */
#define luai_setnodekey(L,key,obj) \
{ LUAI_TKey *k_=(key); const luai_TValue *luai_io_=(obj); \
k_->nk.value_ = luai_io_->value_; k_->nk.tt_ = luai_io_->tt_; \
(void)L; luai_checkliveness(L,luai_io_); }
typedef struct luai_Node {
luai_TValue i_val;
LUAI_TKey i_key;
} luai_Node;
typedef struct luai_Table {
luai_CommonHeader;
luai_lu_byte flags; /* 1<<p means tagmethod(p) is not present */
luai_lu_byte lsizenode; /* log2 of size of 'node' array */
unsigned int sizearray; /* size of 'array' array */
luai_TValue *array; /* array part */
luai_Node *node;
luai_Node *lastfree; /* any free position is before this position */
struct luai_Table *metatable;
LUAI_GCObject *gclist;
} luai_Table;
/*
** 'module' operation for hashing (size is always a power of 2)
*/
#define luai_lmod(s,size) \
(luai_check_exp((size&(size-1))==0, (luai_cast(int, (s) & ((size)-1)))))
#define luai_twoto(x) (1<<(x))
#define luai_sizenode(t) (luai_twoto((t)->lsizenode))
/*
** (address of) a fixed nil value
*/
#define luaO_nilobject (&luaO_nilobject_)
LUAI_DDEC const luai_TValue luaO_nilobject_;
/* size of buffer for 'luaO_utf8esc' function */
#define LUAI_UTF8BUFFSZ 8
LUAI_FUNC int luaO_int2fb (unsigned int x);
LUAI_FUNC int luaO_fb2int (int x);
LUAI_FUNC int luaO_utf8esc (char *buff, unsigned long x);
LUAI_FUNC int luaO_ceillog2 (unsigned int x);
LUAI_FUNC void luaO_arith (lua_State *L, int op, const luai_TValue *p1,
const luai_TValue *p2, luai_TValue *res);
LUAI_FUNC size_t luaO_str2num (const char *s, luai_TValue *o);
LUAI_FUNC int luaO_hexavalue (int c);
LUAI_FUNC void luaO_tostring (lua_State *L, luai_StkId obj);
LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
va_list argp);
LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);
/*__ltm.h__*/
/*
* WARNING: if you change the order of this enumeration,
* grep "ORDER TM" and "ORDER OP"
*/
typedef enum {
LUAI_TM_INDEX,
LUAI_TM_NEWINDEX,
LUAI_TM_GC,
LUAI_TM_MODE,
LUAI_TM_LEN,
LUAI_TM_EQ, /* last tag method with fast access */
LUAI_TM_ADD,
LUAI_TM_SUB,
LUAI_TM_MUL,
LUAI_TM_MOD,
LUAI_TM_POW,
LUAI_TM_DIV,
LUAI_TM_IDIV,
LUAI_TM_BAND,
LUAI_TM_BOR,
LUAI_TM_BXOR,
LUAI_TM_SHL,
LUAI_TM_SHR,
LUAI_TM_UNM,
LUAI_TM_BNOT,
LUAI_TM_LT,
LUAI_TM_LE,
LUAI_TM_CONCAT,
LUAI_TM_CALL,
LUAI_TM_N /* number of elements in the enum */
} luai_TMS;
#define luai_gfasttm(g,et,e) ((et) == NULL ? NULL : \
((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
#define luai_fasttm(l,et,e) luai_gfasttm(LUAI_G(l), et, e)
#define luai_ttypename(x) luaT_typenames_[(x) + 1]
LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS];
LUAI_FUNC const char *luaT_objtypename (lua_State *L, const luai_TValue *o);
LUAI_FUNC const luai_TValue *luaT_gettm (luai_Table *events, luai_TMS event, luai_TString *ename);
LUAI_FUNC const luai_TValue *luaT_gettmbyobj (lua_State *L, const luai_TValue *o,
luai_TMS event);
LUAI_FUNC void luaT_init (lua_State *L);
LUAI_FUNC void luaT_callTM (lua_State *L, const luai_TValue *f, const luai_TValue *p1,
const luai_TValue *p2, luai_TValue *p3, int hasres);
LUAI_FUNC int luaT_callbinTM (lua_State *L, const luai_TValue *p1, const luai_TValue *p2,
luai_StkId res, luai_TMS event);
LUAI_FUNC void luaT_trybinTM (lua_State *L, const luai_TValue *p1, const luai_TValue *p2,
luai_StkId res, luai_TMS event);
LUAI_FUNC int luaT_callorderTM (lua_State *L, const luai_TValue *p1,
const luai_TValue *p2, luai_TMS event);
/*__lmem.h__*/
/*
** This macro reallocs a vector 'b' from 'on' to 'n' elements, where
** each element has size 'e'. In case of arithmetic overflow of the
** product 'n'*'e', it raises an error (calling 'luaM_toobig'). Because
** 'e' is always constant, it avoids the runtime division LUAI_MAX_SIZET/(e).
**
** (The macro is somewhat complex to avoid warnings: The 'sizeof'
** comparison avoids a runtime comparison when overflow cannot occur.
** The compiler should be able to optimize the real test by itself, but
** when it does it, it may give a warning about "comparison is always
** false due to limited range of data type"; the +1 tricks the compiler,
** avoiding this warning but also this optimization.)
*/
#define luaM_reallocv(L,b,on,n,e) \
(((sizeof(n) >= sizeof(size_t) && luai_cast(size_t, (n)) + 1 > LUAI_MAX_SIZET/(e)) \
? luaM_toobig(L) : luai_cast_void(0)) , \
luaM_realloc_(L, (b), (on)*(e), (n)*(e)))
/*
** Arrays of chars do not need any test
*/
#define luaM_reallocvchar(L,b,on,n) \
luai_cast(char *, luaM_realloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char)))
#define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0)
#define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0)
#define luaM_freearray(L, b, n) luaM_realloc_(L, (b), (n)*sizeof(*(b)), 0)
#define luaM_malloc(L,s) luaM_realloc_(L, NULL, 0, (s))
#define luaM_new(L,t) luai_cast(t *, luaM_malloc(L, sizeof(t)))
#define luaM_newvector(L,n,t) \
luai_cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
#define luaM_newobject(L,tag,s) luaM_realloc_(L, NULL, tag, (s))
#define luaM_growvector(L,v,nelems,size,t,limit,e) \
if ((nelems)+1 > (size)) \
((v)=luai_cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
#define luaM_reallocvector(L, v,oldn,n,t) \
((v)=luai_cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
LUAI_FUNC luai_l_noret luaM_toobig (lua_State *L);
/* not to be called directly */
LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *luai_getblock, size_t oldsize,
size_t size);
LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *luai_getblock, int *size,
size_t size_elem, int limit,
const char *what);
/*__lzio.h__*/
#define LUAI_EOZ (-1) /* end of stream */
typedef struct luai_Zio LUAI_ZIO;
#define luai_zgetc(z) (((z)->n--)>0 ? luai_cast_uchar(*(z)->p++) : luaZ_fill(z))
typedef struct luai_Mbuffer {
char *buffer;
size_t n;
size_t buffsize;
} luai_Mbuffer;
#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
#define luaZ_buffer(buff) ((buff)->buffer)
#define luaZ_sizebuffer(buff) ((buff)->buffsize)
#define luaZ_bufflen(buff) ((buff)->n)
#define luaZ_buffremove(buff,i) ((buff)->n -= (i))
#define luaZ_resetbuffer(buff) ((buff)->n = 0)
#define luaZ_resizebuffer(L, buff, size) \
((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \
(buff)->buffsize, size), \
(buff)->buffsize = size)
#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0)
LUAI_FUNC void luaZ_init (lua_State *L, LUAI_ZIO *z, lua_Reader reader,
void *data);
LUAI_FUNC size_t luaZ_read (LUAI_ZIO* z, void *b, size_t n); /* read luai_next n bytes */
/* --------- Private Part ------------------ */
struct luai_Zio {
size_t n; /* bytes still unread */
const char *p; /* current position in buffer */
lua_Reader reader; /* reader function */
void *data; /* additional data */
lua_State *L; /* Lua state (for reader) */
};
LUAI_FUNC int luaZ_fill (LUAI_ZIO *z);
/*__lstate.h__*/
/*
** Some notes about garbage-collected objects: All objects in Lua must
** be kept somehow accessible until being freed, so all objects always
** belong to one (and only one) of these lists, using luai_field 'luai_next' of
** the 'luai_CommonHeader' for the link:
**
** 'allgc': all objects not marked for finalization;
** 'finobj': all objects marked for finalization;
** 'tobefnz': all objects ready to be finalized;
** 'fixedgc': all objects that are not to be collected (currently
** only small strings, such as reserved words).
*/
struct lua_longjmp; /* defined in ldo.c */
/*
** Atomic type (relative to signals) to better ensure that 'lua_sethook'
** is thread safe
*/
#if !defined(luai_l_signalT)
#include <signal.h>
#define luai_l_signalT sig_atomic_t
#endif
/* extra stack space to handle TM calls and some other extras */
#define LUAI_EXTRA_STACK 5
#define LUAI_BASIC_STACK_SIZE (2*LUA_MINSTACK)
/* kinds of Garbage Collection */
#define LUAI_KGC_NORMAL 0
#define LUAI_KGC_EMERGENCY 1 /* gc was forced by an allocation failure */
typedef struct luai_stringtable {
luai_TString **hash;
int nuse; /* number of elements */
int size;
} luai_stringtable;
/*
** Information about a call.
** When a thread yields, 'func' is adjusted to pretend that the
** top function has only the yielded values in its stack; in that
** case, the actual 'func' value is saved in luai_field 'extra'.
** When a function calls another with a continuation, 'extra' keeps
** the function index so that, in case of errors, the continuation
** function can be called with the correct top.
*/
typedef struct luai_CallInfo {
luai_StkId func; /* function index in the stack */
luai_StkId top; /* top for this function */
struct luai_CallInfo *previous, *luai_next; /* dynamic call link */
union {
struct { /* only for Lua functions */
luai_StkId base; /* base for this function */
const Instruction *savedpc;
} l;
struct { /* only for C functions */
lua_KFunction k; /* continuation in case of yields */
ptrdiff_t old_errfunc;
lua_KContext ctx; /* context info. in case of yields */
} c;
} u;
ptrdiff_t extra;
short nresults; /* expected number of results from this function */
unsigned short callstatus;
} luai_CallInfo;
/*
** Bits in luai_CallInfo status
*/
#define LUAI_CIST_OAH (1<<0) /* original value of 'allowhook' */
#define LUAI_CIST_LUA (1<<1) /* call is running a Lua function */
#define LUAI_CIST_HOOKED (1<<2) /* call is running a debug hook */
#define LUAI_CIST_FRESH (1<<3) /* call is running on a fresh invocation
of luaV_execute */
#define LUAI_CIST_YPCALL (1<<4) /* call is a yieldable protected call */
#define LUAI_CIST_TAIL (1<<5) /* call was tail called */
#define LUAI_CIST_HOOKYIELD (1<<6) /* last hook called yielded */
#define LUAI_CIST_LEQ (1<<7) /* using __lt for __le */
#define LUAI_CIST_FIN (1<<8) /* call is running a finalizer */
#define luai_isLua(ci) ((ci)->callstatus & LUAI_CIST_LUA)
/* assume that LUAI_CIST_OAH has offset 0 and that 'v' is strictly 0/1 */
#define luai_setoah(st,v) ((st) = ((st) & ~LUAI_CIST_OAH) | (v))
#define luai_getoah(st) ((st) & LUAI_CIST_OAH)
/*
** 'global state', shared by all threads of this state
*/
typedef struct luai_global_State {
lua_Alloc frealloc; /* function to reallocate memory */
void *ud; /* auxiliary data to 'frealloc' */
luai_l_mem totalbytes; /* number of bytes currently allocated - LUAI_GCdebt */
luai_l_mem LUAI_GCdebt; /* bytes allocated not yet compensated by the collector */
luai_lu_mem LUAI_GCmemtrav; /* memory traversed by the LUAI_GC */
luai_lu_mem LUAI_GCestimate; /* an estimate of the non-garbage memory in use */
luai_stringtable strt; /* hash table for strings */
luai_TValue luai_l_registry;
unsigned int seed; /* randomized seed for hashes */
luai_lu_byte currentwhite;
luai_lu_byte gcstate; /* state of garbage collector */
luai_lu_byte gckind; /* kind of LUAI_GC running */
luai_lu_byte gcrunning; /* true if LUAI_GC is running */
LUAI_GCObject *allgc; /* list of all collectable objects */
LUAI_GCObject **sweepgc; /* current position of sweep in list */
LUAI_GCObject *finobj; /* list of collectable objects with finalizers */
LUAI_GCObject *gray; /* list of gray objects */
LUAI_GCObject *grayagain; /* list of objects to be traversed atomically */
LUAI_GCObject *weak; /* list of tables with weak values */
LUAI_GCObject *ephemeron; /* list of ephemeron tables (weak keys) */
LUAI_GCObject *allweak; /* list of all-weak tables */
LUAI_GCObject *tobefnz; /* list of userdata to be LUAI_GC */
LUAI_GCObject *fixedgc; /* list of objects not to be collected */
struct lua_State *twups; /* list of threads with open upvalues */
unsigned int gcfinnum; /* number of finalizers to call in each LUAI_GC step */
int gcpause; /* size of pause between successive LUAI_GCs */
int gcstepmul; /* LUAI_GC 'granularity' */
lua_CFunction panic; /* to be called in unprotected errors */
struct lua_State *mainthread;
const lua_Number *version; /* pointer to version number */
luai_TString *memerrmsg; /* memory-error message */
luai_TString *tmname[LUAI_TM_N]; /* array with tag-method names */
struct luai_Table *mt[LUA_NUMTAGS]; /* metatables for basic types */
luai_TString *strcache[LUAI_STRCACHE_N][LUAI_STRCACHE_M]; /* cache for strings in API */
} luai_global_State;
/*
** 'per thread' state
*/
struct lua_State {
luai_CommonHeader;
unsigned short nci; /* number of items in 'ci' list */
luai_lu_byte status;
luai_StkId top; /* first free slot in the stack */
luai_global_State *luai_l_G;
luai_CallInfo *ci; /* call info for current function */
const Instruction *oldpc; /* last pc traced */
luai_StkId stack_last; /* last free slot in the stack */
luai_StkId stack; /* stack base */
luai_UpVal *openupval; /* list of open upvalues in this stack */
LUAI_GCObject *gclist;
struct lua_State *twups; /* list of threads with open upvalues */
struct lua_longjmp *errorJmp; /* current error luai_recover point */
luai_CallInfo base_ci; /* luai_CallInfo for first level (C calling Lua) */
volatile lua_Hook hook;
ptrdiff_t errfunc; /* current error handling function (stack index) */
int stacksize;
int basehookcount;
int hookcount;
unsigned short nny; /* number of non-yieldable calls in stack */
unsigned short nCcalls; /* number of nested C calls */
luai_l_signalT hookmask;
luai_lu_byte allowhook;
};
#define LUAI_G(L) (L->luai_l_G)
/*
** Union of all collectable objects (only for conversions)
*/
union LUAI_GCUnion {
LUAI_GCObject gc; /* common header */
struct luai_TString ts;
struct luai_Udata u;
union luai_Closure cl;
struct luai_Table h;
struct luai_Proto p;
struct lua_State th; /* thread */
};
#define luai_cast_u(o) luai_cast(union LUAI_GCUnion *, (o))
/* macros to convert a LUAI_GCObject into a specific value */
#define luai_gco2ts(o) \
luai_check_exp(luai_novariant((o)->tt) == LUA_TSTRING, &((luai_cast_u(o))->ts))
#define luai_gco2u(o) luai_check_exp((o)->tt == LUA_TUSERDATA, &((luai_cast_u(o))->u))
#define luai_gco2lcl(o) luai_check_exp((o)->tt == LUA_TLCL, &((luai_cast_u(o))->cl.l))
#define luai_gco2ccl(o) luai_check_exp((o)->tt == LUA_TCCL, &((luai_cast_u(o))->cl.c))
#define luai_gco2cl(o) \
luai_check_exp(luai_novariant((o)->tt) == LUA_TFUNCTION, &((luai_cast_u(o))->cl))
#define luai_gco2t(o) luai_check_exp((o)->tt == LUA_TTABLE, &((luai_cast_u(o))->h))
#define luai_gco2p(o) luai_check_exp((o)->tt == LUA_TPROTO, &((luai_cast_u(o))->p))
#define luai_gco2th(o) luai_check_exp((o)->tt == LUA_TTHREAD, &((luai_cast_u(o))->th))
/* macro to convert a Lua object into a LUAI_GCObject */
#define luai_obj2gco(v) \
luai_check_exp(luai_novariant((v)->tt) < LUA_TDEADKEY, (&(luai_cast_u(v)->gc)))
/* actual number of total bytes allocated */
#define luai_gettotalbytes(g) luai_cast(luai_lu_mem, (g)->totalbytes + (g)->LUAI_GCdebt)
LUAI_FUNC void luaE_setdebt (luai_global_State *g, luai_l_mem debt);
LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
LUAI_FUNC luai_CallInfo *luaE_extendCI (lua_State *L);
LUAI_FUNC void luaE_freeCI (lua_State *L);
LUAI_FUNC void luaE_shrinkCI (lua_State *L);
/*__lapi.h__*/
#define luai_api_incr_top(L) {L->top++; luai_api_check(L, L->top <= L->ci->top, \
"stack overflow");}
#define luai_adjustresults(L,nres) \
{ if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }
#define luai_api_checknelems(L,n) luai_api_check(L, (n) < (L->top - L->ci->func), \
"not enough elements in the stack")
/*__llex.h__*/
#define LUAI_FIRST_RESERVED 257
#if !defined(LUA_ENV)
#define LUA_ENV "_ENV"
#endif
/*
* WARNING: if you change the order of this enumeration,
* grep "ORDER LUAI_RESERVED"
*/
enum LUAI_RESERVED {
/* terminal symbols denoted by reserved words */
LUAI_TK_AND = LUAI_FIRST_RESERVED, LUAI_TK_BREAK,
LUAI_TK_DO, LUAI_TK_ELSE, LUAI_TK_ELSEIF, LUAI_TK_END, LUAI_TK_FALSE, LUAI_TK_FOR, LUAI_TK_FUNCTION,
LUAI_TK_GOTO, LUAI_TK_IF, LUAI_TK_IN, LUAI_TK_LOCAL, LUAI_TK_NIL, LUAI_TK_NOT, LUAI_TK_OR, LUAI_TK_REPEAT,
LUAI_TK_RETURN, LUAI_TK_THEN, LUAI_TK_TRUE, LUAI_TK_UNTIL, LUAI_TK_WHILE,
/* other terminal symbols */
LUAI_TK_IDIV, LUAI_TK_CONCAT, LUAI_TK_DOTS, LUAI_TK_EQ, LUAI_TK_GE, LUAI_TK_LE, LUAI_TK_NE,
LUAI_TK_SHL, LUAI_TK_SHR,
LUAI_TK_DBCOLON, LUAI_TK_EOS,
LUAI_TK_FLT, LUAI_TK_INT, LUAI_TK_NAME, LUAI_TK_STRING
};
/* number of reserved words */
#define LUAI_NUM_RESERVED (luai_cast(int, LUAI_TK_WHILE-LUAI_FIRST_RESERVED+1))
typedef union {
lua_Number r;
lua_Integer i;
luai_TString *ts;
} luai_SemInfo; /* semantics information */
typedef struct luai_Token {
int token;
luai_SemInfo seminfo;
} luai_Token;
/* state of the lexer plus state of the parser when shared by all
functions */
typedef struct luai_LexState {
int current; /* current character (charint) */
int linenumber; /* input line counter */
int lastline; /* line of last token 'consumed' */
luai_Token t; /* current token */
luai_Token lookahead; /* look ahead token */
struct luai_FuncState *fs; /* current function (parser) */
struct lua_State *L;
LUAI_ZIO *z; /* input stream */
luai_Mbuffer *buff; /* buffer for tokens */
luai_Table *h; /* to avoid collection/reuse strings */
struct luai_Dyndata *dyd; /* dynamic structures used by the parser */
luai_TString *source; /* current source name */
luai_TString *envn; /* environment variable name */
} luai_LexState;
LUAI_FUNC void luaX_init (lua_State *L);
LUAI_FUNC void luaX_setinput (lua_State *L, luai_LexState *ls, LUAI_ZIO *z,
luai_TString *source, int firstchar);
LUAI_FUNC luai_TString *luaX_newstring (luai_LexState *ls, const char *str, size_t l);
LUAI_FUNC void luaX_next (luai_LexState *ls);
LUAI_FUNC int luaX_lookahead (luai_LexState *ls);
LUAI_FUNC luai_l_noret luaX_syntaxerror (luai_LexState *ls, const char *s);
LUAI_FUNC const char *luaX_token2str (luai_LexState *ls, int token);
/*__lopcodes.h__*/
/*===========================================================================
We assume that instructions are unsigned numbers.
All instructions have an opcode in the first 6 bits.
Instructions can have the following fields:
'A' : 8 bits
'B' : 9 bits
'C' : 9 bits
'Ax' : 26 bits ('A', 'B', and 'C' together)
'Bx' : 18 bits ('B' and 'C' together)
'sBx' : signed Bx
A signed argument is represented in excess K; that is, the number
value is the unsigned value minus K. K is exactly the maximum value
for that argument (so that -max is represented by 0, and +max is
represented by 2*max), which is half the maximum for the corresponding
unsigned argument.
===========================================================================*/
enum luai_OpMode {luai_iABC, luai_iABx, luai_iAsBx, luai_iAx}; /* basic instruction format */
/*
** size and position of opcode arguments.
*/
#define luai_SIZE_C 9
#define luai_SIZE_B 9
#define luai_SIZE_Bx (luai_SIZE_C + luai_SIZE_B)
#define luai_SIZE_A 8
#define luai_SIZE_Ax (luai_SIZE_C + luai_SIZE_B + luai_SIZE_A)
#define luai_SIZE_OP 6
#define luai_POS_OP 0
#define luai_POS_A (luai_POS_OP + luai_SIZE_OP)
#define luai_POS_C (luai_POS_A + luai_SIZE_A)
#define luai_POS_B (luai_POS_C + luai_SIZE_C)
#define luai_POS_Bx luai_POS_C
#define luai_POS_Ax luai_POS_A
/*
** limits for opcode arguments.
** we use (signed) int to manipulate most arguments,
** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
*/
#if luai_SIZE_Bx < LUAI_BITSINT-1
#define luai_MAXARG_Bx ((1<<luai_SIZE_Bx)-1)
#define luai_MAXARG_sBx (luai_MAXARG_Bx>>1) /* 'sBx' is signed */
#else
#define luai_MAXARG_Bx LUAI_MAX_INT
#define luai_MAXARG_sBx LUAI_MAX_INT
#endif
#if luai_SIZE_Ax < LUAI_BITSINT-1
#define luai_MAXARG_Ax ((1<<luai_SIZE_Ax)-1)
#else
#define luai_MAXARG_Ax LUAI_MAX_INT
#endif
#define luai_MAXARG_A ((1<<luai_SIZE_A)-1)
#define luai_MAXARG_B ((1<<luai_SIZE_B)-1)
#define luai_MAXARG_C ((1<<luai_SIZE_C)-1)
/* creates a mask with 'n' 1 bits at position 'p' */
#define luai_MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p))
/* creates a mask with 'n' 0 bits at position 'p' */
#define luai_MASK0(n,p) (~luai_MASK1(n,p))
/*
** the following macros help to manipulate instructions
*/
#define luai_GETOPCODE(i) (luai_cast(luai_OpCode, ((i)>>luai_POS_OP) & luai_MASK1(luai_SIZE_OP,0)))
#define luai_SETOPCODE(i,o) ((i) = (((i)&luai_MASK0(luai_SIZE_OP,luai_POS_OP)) | \
((luai_cast(Instruction, o)<<luai_POS_OP)&luai_MASK1(luai_SIZE_OP,luai_POS_OP))))
#define luai_getarg(i,pos,size) (luai_cast(int, ((i)>>pos) & luai_MASK1(size,0)))
#define luai_setarg(i,v,pos,size) ((i) = (((i)&luai_MASK0(size,pos)) | \
((luai_cast(Instruction, v)<<pos)&luai_MASK1(size,pos))))
#define luai_GETARG_A(i) luai_getarg(i, luai_POS_A, luai_SIZE_A)
#define luai_SETARG_A(i,v) luai_setarg(i, v, luai_POS_A, luai_SIZE_A)
#define luai_GETARG_B(i) luai_getarg(i, luai_POS_B, luai_SIZE_B)
#define luai_SETARG_B(i,v) luai_setarg(i, v, luai_POS_B, luai_SIZE_B)
#define luai_GETARG_C(i) luai_getarg(i, luai_POS_C, luai_SIZE_C)
#define luai_SETARG_C(i,v) luai_setarg(i, v, luai_POS_C, luai_SIZE_C)
#define luai_GETARG_Bx(i) luai_getarg(i, luai_POS_Bx, luai_SIZE_Bx)
#define luai_SETARG_Bx(i,v) luai_setarg(i, v, luai_POS_Bx, luai_SIZE_Bx)
#define luai_GETARG_Ax(i) luai_getarg(i, luai_POS_Ax, luai_SIZE_Ax)
#define luai_SETARG_Ax(i,v) luai_setarg(i, v, luai_POS_Ax, luai_SIZE_Ax)
#define luai_GETARG_sBx(i) (luai_GETARG_Bx(i)-luai_MAXARG_sBx)
#define luai_SETARG_sBx(i,b) luai_SETARG_Bx((i),luai_cast(unsigned int, (b)+luai_MAXARG_sBx))
#define luai_CREATE_ABC(o,a,b,c) ((luai_cast(Instruction, o)<<luai_POS_OP) \
| (luai_cast(Instruction, a)<<luai_POS_A) \
| (luai_cast(Instruction, b)<<luai_POS_B) \
| (luai_cast(Instruction, c)<<luai_POS_C))
#define luai_CREATE_ABx(o,a,bc) ((luai_cast(Instruction, o)<<luai_POS_OP) \
| (luai_cast(Instruction, a)<<luai_POS_A) \
| (luai_cast(Instruction, bc)<<luai_POS_Bx))
#define luai_CREATE_Ax(o,a) ((luai_cast(Instruction, o)<<luai_POS_OP) \
| (luai_cast(Instruction, a)<<luai_POS_Ax))
/*
** Macros to operate RK indices
*/
/* this bit 1 means constant (0 means register) */
#define luai_BITRK (1 << (luai_SIZE_B - 1))
/* test whether value is a constant */
#define luai_ISK(x) ((x) & luai_BITRK)
/* gets the index of the constant */
#define luai_INDEXK(r) ((int)(r) & ~luai_BITRK)
#if !defined(luai_MAXINDEXRK) /* (for debugging only) */
#define luai_MAXINDEXRK (luai_BITRK - 1)
#endif
/* code a constant index as a RK value */
#define luai_RKASK(x) ((x) | luai_BITRK)
/*
** invalid register that fits in 8 bits
*/
#define luai_NO_REG luai_MAXARG_A
/*
** R(x) - register
** Kst(x) - constant (in constant table)
** RK(x) == if luai_ISK(x) then Kst(luai_INDEXK(x)) else R(x)
*/
/*
** grep "ORDER OP" if you change these enums
*/
typedef enum {
/*----------------------------------------------------------------------
name args description
------------------------------------------------------------------------*/
luai_OP_MOVE,/* A B R(A) := R(B) */
luai_OP_LOADK,/* A Bx R(A) := Kst(Bx) */
luai_OP_LOADKX,/* A R(A) := Kst(extra arg) */
luai_OP_LOADBOOL,/* A B C R(A) := (Bool)B; if (C) pc++ */
luai_OP_LOADNIL,/* A B R(A), R(A+1), ..., R(A+B) := nil */
luai_OP_GETUPVAL,/* A B R(A) := UpValue[B] */
luai_OP_GETTABUP,/* A B C R(A) := UpValue[B][RK(C)] */
luai_OP_GETTABLE,/* A B C R(A) := R(B)[RK(C)] */
luai_OP_SETTABUP,/* A B C UpValue[A][RK(B)] := RK(C) */
luai_OP_SETUPVAL,/* A B UpValue[B] := R(A) */
luai_OP_SETTABLE,/* A B C R(A)[RK(B)] := RK(C) */
luai_OP_NEWTABLE,/* A B C R(A) := {} (size = B,C) */
luai_OP_SELF,/* A B C R(A+1) := R(B); R(A) := R(B)[RK(C)] */
luai_OP_ADD,/* A B C R(A) := RK(B) + RK(C) */
luai_OP_SUB,/* A B C R(A) := RK(B) - RK(C) */
luai_OP_MUL,/* A B C R(A) := RK(B) * RK(C) */
luai_OP_MOD,/* A B C R(A) := RK(B) % RK(C) */
luai_OP_POW,/* A B C R(A) := RK(B) ^ RK(C) */
luai_OP_DIV,/* A B C R(A) := RK(B) / RK(C) */
luai_OP_IDIV,/* A B C R(A) := RK(B) // RK(C) */
luai_OP_BAND,/* A B C R(A) := RK(B) & RK(C) */
luai_OP_BOR,/* A B C R(A) := RK(B) | RK(C) */
luai_OP_BXOR,/* A B C R(A) := RK(B) ~ RK(C) */
luai_OP_SHL,/* A B C R(A) := RK(B) << RK(C) */
luai_OP_SHR,/* A B C R(A) := RK(B) >> RK(C) */
luai_OP_UNM,/* A B R(A) := -R(B) */
luai_OP_BNOT,/* A B R(A) := ~R(B) */
luai_OP_NOT,/* A B R(A) := not R(B) */
luai_OP_LEN,/* A B R(A) := length of R(B) */
luai_OP_CONCAT,/* A B C R(A) := R(B).. ... ..R(C) */
luai_OP_JMP,/* A sBx pc+=sBx; if (A) close all upvalues >= R(A - 1) */
luai_OP_EQ,/* A B C if ((RK(B) == RK(C)) ~= A) then pc++ */
luai_OP_LT,/* A B C if ((RK(B) < RK(C)) ~= A) then pc++ */
luai_OP_LE,/* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */
luai_OP_TEST,/* A C if not (R(A) <=> C) then pc++ */
luai_OP_TESTSET,/* A B C if (R(B) <=> C) then R(A) := R(B) else pc++ */
luai_OP_CALL,/* A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
luai_OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */
luai_OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */
luai_OP_FORLOOP,/* A sBx R(A)+=R(A+2);
if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
luai_OP_FORPREP,/* A sBx R(A)-=R(A+2); pc+=sBx */
luai_OP_TFORCALL,/* A C R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2)); */
luai_OP_TFORLOOP,/* A sBx if R(A+1) ~= nil then { R(A)=R(A+1); pc += sBx }*/
luai_OP_SETLIST,/* A B C R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B */
luai_OP_CLOSURE,/* A Bx R(A) := closure(KPROTO[Bx]) */
luai_OP_VARARG,/* A B R(A), R(A+1), ..., R(A+B-2) = vararg */
luai_OP_EXTRAARG/* Ax extra (larger) argument for previous opcode */
} luai_OpCode;
#define luai_NUM_OPCODES (luai_cast(int, luai_OP_EXTRAARG) + 1)
/*===========================================================================
Notes:
(*) In luai_OP_CALL, if (B == 0) then B = top. If (C == 0), then 'top' is
set to last_result+1, so luai_next open instruction (luai_OP_CALL, luai_OP_RETURN,
luai_OP_SETLIST) may use 'top'.
(*) In luai_OP_VARARG, if (B == 0) then use actual number of varargs and
set top (like in luai_OP_CALL with C == 0).
(*) In luai_OP_RETURN, if (B == 0) then return up to 'top'.
(*) In luai_OP_SETLIST, if (B == 0) then B = 'top'; if (C == 0) then luai_next
'instruction' is EXTRAARG(real C).
(*) In luai_OP_LOADKX, the luai_next 'instruction' is always EXTRAARG.
(*) For comparisons, A specifies what condition the test should accept
(true or false).
(*) All 'skips' (pc++) assume that luai_next instruction is a jump.
===========================================================================*/
/*
** luai_masks for instruction properties. The format is:
** bits 0-1: op mode
** bits 2-3: C arg mode
** bits 4-5: B arg mode
** bit 6: instruction set register A
** bit 7: operator is a test (luai_next instruction must be a jump)
*/
enum luai_OpArgMask {
luai_OpArgN, /* argument is not used */
luai_OpArgU, /* argument is used */
luai_OpArgR, /* argument is a register or a jump offset */
luai_OpArgK /* argument is a constant or register/constant */
};
LUAI_DDEC const luai_lu_byte luaP_opmodes[luai_NUM_OPCODES];
#define luai_getOpMode(m) (luai_cast(enum luai_OpMode, luaP_opmodes[m] & 3))
#define luai_getBMode(m) (luai_cast(enum luai_OpArgMask, (luaP_opmodes[m] >> 4) & 3))
#define luai_getCMode(m) (luai_cast(enum luai_OpArgMask, (luaP_opmodes[m] >> 2) & 3))
#define luai_testAMode(m) (luaP_opmodes[m] & (1 << 6))
#define luai_testTMode(m) (luaP_opmodes[m] & (1 << 7))
LUAI_DDEC const char *const luaP_opnames[luai_NUM_OPCODES+1]; /* opcode names */
/* number of list items to accumulate before a SETLIST instruction */
#define LUAI_LFIELDS_PER_FLUSH 50
/*__lparser.h__*/
/*
** Expression and variable descriptor.
** Code generation for variables and expressions can be delayed to allow
** optimizations; An 'luai_expdesc' structure describes a potentially-delayed
** variable/expression. It has a description of its "main" value plus a
** list of conditional jumps that can also produce its value (generated
** by short-circuit operators 'and'/'or').
*/
/* kinds of variables/expressions */
typedef enum {
LUAI_VVOID, /* when 'luai_expdesc' describes the last expression a list,
this kind means an empty list (so, no expression) */
LUAI_VNIL, /* constant nil */
LUAI_VTRUE, /* constant true */
LUAI_VFALSE, /* constant false */
LUAI_VK, /* constant in 'k'; info = index of constant in 'k' */
LUAI_VKFLT, /* floating constant; nval = numerical float value */
LUAI_VKINT, /* integer constant; nval = numerical integer value */
LUAI_VNONRELOC, /* expression has its value in a fixed register;
info = result register */
LUAI_VLOCAL, /* local variable; info = local register */
LUAI_VUPVAL, /* upvalue variable; info = index of upvalue in 'upvalues' */
LUAI_VINDEXED, /* indexed variable;
ind.vt = whether 't' is register or upvalue;
ind.t = table register or upvalue;
ind.idx = key's R/K index */
LUAI_VJMP, /* expression is a test/comparison;
info = pc of corresponding jump instruction */
LUAI_VRELOCABLE, /* expression can put result in any register;
info = instruction pc */
LUAI_VCALL, /* expression is a function call; info = instruction pc */
LUAI_VVARARG /* vararg expression; info = instruction pc */
} luai_expkind;
#define luai_vkisvar(k) (LUAI_VLOCAL <= (k) && (k) <= LUAI_VINDEXED)
#define luai_vkisinreg(k) ((k) == LUAI_VNONRELOC || (k) == LUAI_VLOCAL)
typedef struct luai_expdesc {
luai_expkind k;
union {
lua_Integer ival; /* for LUAI_VKINT */
lua_Number nval; /* for LUAI_VKFLT */
int info; /* for generic use */
struct { /* for indexed variables (LUAI_VINDEXED) */
short idx; /* index (R/K) */
luai_lu_byte t; /* table (register or upvalue) */
luai_lu_byte vt; /* whether 't' is register (LUAI_VLOCAL) or upvalue (LUAI_VUPVAL) */
} ind;
} u;
int t; /* patch list of 'exit when true' */
int f; /* patch list of 'exit when false' */
} luai_expdesc;
/* description of active local variable */
typedef struct luai_Vardesc {
short idx; /* variable index in stack */
} luai_Vardesc;
/* description of pending goto statements and label statements */
typedef struct luai_Labeldesc {
luai_TString *name; /* label identifier */
int pc; /* position in code */
int line; /* line where it appeared */
luai_lu_byte nactvar; /* local level where it appears in current luai_getblock */
} luai_Labeldesc;
/* list of labels or gotos */
typedef struct luai_Labellist {
luai_Labeldesc *arr; /* array */
int n; /* number of entries in use */
int size; /* array size */
} luai_Labellist;
/* dynamic structures used by the parser */
typedef struct luai_Dyndata {
struct { /* list of active local variables */
luai_Vardesc *arr;
int n;
int size;
} actvar;
luai_Labellist gt; /* list of pending gotos */
luai_Labellist label; /* list of active labels */
} luai_Dyndata;
/* control of blocks */
struct luai_BlockCnt; /* defined in lparser.c */
/* state needed to generate code for a given function */
typedef struct luai_FuncState {
luai_Proto *f; /* current function header */
struct luai_FuncState *prev; /* enclosing function */
struct luai_LexState *ls; /* lexical state */
struct luai_BlockCnt *bl; /* chain of current blocks */
int pc; /* luai_next position to code (equivalent to 'ncode') */
int lasttarget; /* 'label' of last 'jump label' */
int jpc; /* list of pending jumps to 'pc' */
int nk; /* number of elements in 'k' */
int np; /* number of elements in 'p' */
int firstlocal; /* index of first local var (in luai_Dyndata array) */
short nlocvars; /* number of elements in 'f->locvars' */
luai_lu_byte nactvar; /* number of active local variables */
luai_lu_byte nups; /* number of upvalues */
luai_lu_byte luai_freereg; /* first free register */
} luai_FuncState;
LUAI_FUNC luai_LClosure *luaY_parser (lua_State *L, LUAI_ZIO *z, luai_Mbuffer *buff,
luai_Dyndata *dyd, const char *name, int firstchar);
/*__lcode.h__*/
/*
** Marks the end of a patch list. It is an invalid value both as an absolute
** address, and as a list link (would link an element to itself).
*/
#define LUAI_NO_JUMP (-1)
/*
** grep "ORDER OPR" if you change these enums (ORDER OP)
*/
typedef enum luai_BinOpr {
LUAI_OPRADD, LUAI_OPRSUB, LUAI_OPRMUL, LUAI_OPRMOD, LUAI_OPRPOW,
LUAI_OPRDIV,
LUAI_OPRIDIV,
LUAI_OPRBAND, LUAI_OPRBOR, LUAI_OPRBXOR,
LUAI_OPRSHL, LUAI_OPRSHR,
LUAI_OPRCONCAT,
LUAI_OPREQ, LUAI_OPRLT, LUAI_OPRLE,
LUAI_OPRNE, LUAI_OPRGT, LUAI_OPRGE,
LUAI_OPRAND, LUAI_OPROR,
LUAI_OPRNOBINOPR
} luai_BinOpr;
typedef enum laui_UnOpr { LUAI_OPRMINUS, LUAI_OPRBNOT, LUAI_OPRNOT, LUAI_OPRLEN, LUAI_OPRNOUNOPR } laui_UnOpr;
/* get (pointer to) instruction of given 'luai_expdesc' */
#define luai_getinstruction(fs,e) ((fs)->f->code[(e)->u.info])
#define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+luai_MAXARG_sBx)
#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET)
#define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t)
LUAI_FUNC int luaK_codeABx (luai_FuncState *fs, luai_OpCode o, int A, unsigned int Bx);
LUAI_FUNC int luaK_codeABC (luai_FuncState *fs, luai_OpCode o, int A, int B, int C);
LUAI_FUNC int luaK_codek (luai_FuncState *fs, int reg, int k);
LUAI_FUNC void luaK_fixline (luai_FuncState *fs, int line);
LUAI_FUNC void luaK_nil (luai_FuncState *fs, int from, int n);
LUAI_FUNC void luaK_reserveregs (luai_FuncState *fs, int n);
LUAI_FUNC void luaK_checkstack (luai_FuncState *fs, int n);
LUAI_FUNC int luaK_stringK (luai_FuncState *fs, luai_TString *s);
LUAI_FUNC int luaK_intK (luai_FuncState *fs, lua_Integer n);
LUAI_FUNC void luaK_dischargevars (luai_FuncState *fs, luai_expdesc *e);
LUAI_FUNC int luaK_exp2anyreg (luai_FuncState *fs, luai_expdesc *e);
LUAI_FUNC void luaK_exp2anyregup (luai_FuncState *fs, luai_expdesc *e);
LUAI_FUNC void luaK_exp2nextreg (luai_FuncState *fs, luai_expdesc *e);
LUAI_FUNC void luaK_exp2val (luai_FuncState *fs, luai_expdesc *e);
LUAI_FUNC int luaK_exp2RK (luai_FuncState *fs, luai_expdesc *e);
LUAI_FUNC void luaK_self (luai_FuncState *fs, luai_expdesc *e, luai_expdesc *key);
LUAI_FUNC void luaK_indexed (luai_FuncState *fs, luai_expdesc *t, luai_expdesc *k);
LUAI_FUNC void luaK_goiftrue (luai_FuncState *fs, luai_expdesc *e);
LUAI_FUNC void luaK_goiffalse (luai_FuncState *fs, luai_expdesc *e);
LUAI_FUNC void luaK_storevar (luai_FuncState *fs, luai_expdesc *var, luai_expdesc *e);
LUAI_FUNC void luaK_setreturns (luai_FuncState *fs, luai_expdesc *e, int nresults);
LUAI_FUNC void luaK_setoneret (luai_FuncState *fs, luai_expdesc *e);
LUAI_FUNC int luaK_jump (luai_FuncState *fs);
LUAI_FUNC void luaK_ret (luai_FuncState *fs, int first, int nret);
LUAI_FUNC void luaK_patchlist (luai_FuncState *fs, int list, int target);
LUAI_FUNC void luaK_patchtohere (luai_FuncState *fs, int list);
LUAI_FUNC void luaK_patchclose (luai_FuncState *fs, int list, int level);
LUAI_FUNC void luaK_concat (luai_FuncState *fs, int *l1, int l2);
LUAI_FUNC int luaK_getlabel (luai_FuncState *fs);
LUAI_FUNC void luaK_prefix (luai_FuncState *fs, laui_UnOpr op, luai_expdesc *v, int line);
LUAI_FUNC void luaK_infix (luai_FuncState *fs, luai_BinOpr op, luai_expdesc *v);
LUAI_FUNC void luaK_posfix (luai_FuncState *fs, luai_BinOpr op, luai_expdesc *v1,
luai_expdesc *v2, int line);
LUAI_FUNC void luaK_setlist (luai_FuncState *fs, int base, int nelems, int tostore);
/*__lctype.h__*/
/*
** WARNING: the functions defined here do not necessarily correspond
** to the similar functions in the standard C ctype.h. They are
** optimized for the specific needs of Lua
*/
#if !defined(LUA_USE_CTYPE)
#if 'A' == 65 && '0' == 48
/* ASCII case: can use its own tables; faster and fixed */
#define LUA_USE_CTYPE 0
#else
/* must use standard C ctype */
#define LUA_USE_CTYPE 1
#endif
#endif
#if !LUA_USE_CTYPE /* { */
#define LUAI_ALPHABIT 0
#define LUAI_DIGITBIT 1
#define LUAI_PRINTBIT 2
#define LUAI_SPACEBIT 3
#define LUAI_XDIGITBIT 4
#define LUAI_MASK(B) (1 << (B))
/*
** add 1 to char to allow index -1 (LUAI_EOZ)
*/
#define luai_testprop(c,p) (luai_ctype_[(c)+1] & (p))
/*
** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
*/
#define luai_lislalpha(c) luai_testprop(c, LUAI_MASK(LUAI_ALPHABIT))
#define luai_lislalnum(c) luai_testprop(c, (LUAI_MASK(LUAI_ALPHABIT) | LUAI_MASK(LUAI_DIGITBIT)))
#define luai_lisdigit(c) luai_testprop(c, LUAI_MASK(LUAI_DIGITBIT))
#define luai_lisspace(c) luai_testprop(c, LUAI_MASK(LUAI_SPACEBIT))
#define luai_lisprint(c) luai_testprop(c, LUAI_MASK(LUAI_PRINTBIT))
#define luai_lisxdigit(c) luai_testprop(c, LUAI_MASK(LUAI_XDIGITBIT))
/*
** this 'luai_tolower' only works for alphabetic characters
*/
#define luai_tolower(c) ((c) | ('A' ^ 'a'))
/* two more entries for 0 and -1 (LUAI_EOZ) */
LUAI_DDEC const luai_lu_byte luai_ctype_[UCHAR_MAX + 2];
#else /* }{ */
/*
** use standard C ctypes
*/
#include <ctype.h>
#define luai_lislalpha(c) (isalpha(c) || (c) == '_')
#define luai_lislalnum(c) (isalnum(c) || (c) == '_')
#define luai_lisdigit(c) (isdigit(c))
#define luai_lisspace(c) (isspace(c))
#define luai_lisprint(c) (isprint(c))
#define luai_lisxdigit(c) (isxdigit(c))
#define luai_tolower(c) (tolower(c))
#endif /* } */
/*__ldebug.h__*/
#define luai_pcRel(pc, p) (luai_cast(int, (pc) - (p)->code) - 1)
#define luai_getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : -1)
#define luai_resethookcount(L) (L->hookcount = L->basehookcount)
LUAI_FUNC luai_l_noret luaG_typeerror (lua_State *L, const luai_TValue *o,
const char *opname);
LUAI_FUNC luai_l_noret luaG_concaterror (lua_State *L, const luai_TValue *p1,
const luai_TValue *p2);
LUAI_FUNC luai_l_noret luaG_opinterror (lua_State *L, const luai_TValue *p1,
const luai_TValue *p2,
const char *msg);
LUAI_FUNC luai_l_noret luaG_tointerror (lua_State *L, const luai_TValue *p1,
const luai_TValue *p2);
LUAI_FUNC luai_l_noret luaG_ordererror (lua_State *L, const luai_TValue *p1,
const luai_TValue *p2);
LUAI_FUNC luai_l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg,
luai_TString *src, int line);
LUAI_FUNC luai_l_noret luaG_errormsg (lua_State *L);
LUAI_FUNC void luaG_traceexec (lua_State *L);
/*__ldo.h__*/
/*
** Macro to luai_check stack size and grow stack if needed. Parameters
** 'pre'/'pos' allow the macro to preserve a pointer into the
** stack across reallocations, doing the work only when needed.
** 'luai_condmovestack' is used in heavy tests to force a stack reallocation
** at every luai_check.
*/
#define luaD_checkstackaux(L,n,pre,pos) \
if (L->stack_last - L->top <= (n)) \
{ pre; luaD_growstack(L, n); pos; } else { luai_condmovestack(L,pre,pos); }
/* In general, 'pre'/'pos' are empty (nothing to luai_save) */
#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0)
#define luai_savestack(L,p) ((char *)(p) - (char *)L->stack)
#define luai_restorestack(L,n) ((luai_TValue *)((char *)L->stack + (n)))
/* type of protected functions, to be ran by 'runprotected' */
typedef void (*Pfunc) (lua_State *L, void *ud);
LUAI_FUNC int luaD_protectedparser (lua_State *L, LUAI_ZIO *z, const char *name,
const char *mode);
LUAI_FUNC void luaD_hook (lua_State *L, int event, int line);
LUAI_FUNC int luaD_precall (lua_State *L, luai_StkId func, int nresults);
LUAI_FUNC void luaD_call (lua_State *L, luai_StkId func, int nResults);
LUAI_FUNC void luaD_callnoyield (lua_State *L, luai_StkId func, int nResults);
LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
ptrdiff_t oldtop, ptrdiff_t ef);
LUAI_FUNC int luaD_poscall (lua_State *L, luai_CallInfo *ci, luai_StkId firstResult,
int nres);
LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
LUAI_FUNC void luaD_growstack (lua_State *L, int n);
LUAI_FUNC void luaD_shrinkstack (lua_State *L);
LUAI_FUNC void luaD_inctop (lua_State *L);
LUAI_FUNC luai_l_noret luaD_throw (lua_State *L, int errcode);
LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
/*__lfunc.h__*/
#define luai_sizeCclosure(n) (luai_cast(int, sizeof(luai_CClosure)) + \
luai_cast(int, sizeof(luai_TValue)*((n)-1)))
#define luai_sizeLclosure(n) (luai_cast(int, sizeof(luai_LClosure)) + \
luai_cast(int, sizeof(luai_TValue *)*((n)-1)))
/* test whether thread is in 'twups' list */
#define luai_isintwups(L) (L->twups != L)
/*
** maximum number of upvalues in a closure (both C and Lua). (Value
** must fit in a VM register.)
*/
#define LUAI_MAXUPVAL 255
/*
** Upvalues for Lua closures
*/
struct luai_UpVal {
luai_TValue *v; /* points to stack or to its own value */
luai_lu_mem refcount; /* reference counter */
union {
struct { /* (when open) */
luai_UpVal *luai_next; /* linked list */
int touched; /* mark to avoid cycles with dead threads */
} open;
luai_TValue value; /* the value (when closed) */
} u;
};
#define luai_upisopen(up) ((up)->v != &(up)->u.value)
LUAI_FUNC luai_Proto *luaF_newproto (lua_State *L);
LUAI_FUNC luai_CClosure *luaF_newCclosure (lua_State *L, int nelems);
LUAI_FUNC luai_LClosure *luaF_newLclosure (lua_State *L, int nelems);
LUAI_FUNC void luaF_initupvals (lua_State *L, luai_LClosure *cl);
LUAI_FUNC luai_UpVal *luaF_findupval (lua_State *L, luai_StkId level);
LUAI_FUNC void luaF_close (lua_State *L, luai_StkId level);
LUAI_FUNC void luaF_freeproto (lua_State *L, luai_Proto *f);
LUAI_FUNC const char *luaF_getlocalname (const luai_Proto *func, int local_number,
int pc);
/*__lgc.h__*/
/*
** Collectable objects may have one of three colors: white, which
** means the object is not marked; gray, which means the
** object is marked, but its references may be not marked; and
** black, which means that the object and all its references are marked.
** The main invariant of the garbage collector, while marking objects,
** is that a black object can never point to a white one. Moreover,
** any gray object must be in a "gray list" (gray, grayagain, weak,
** allweak, ephemeron) so that it can be visited again before finishing
** the collection cycle. These lists have no meaning when the invariant
** is not being enforced (e.g., sweep phase).
*/
/* how much to allocate before luai_next LUAI_GC step */
#if !defined(LUA_GCSTEPSIZE)
/* ~100 small strings */
#define LUA_GCSTEPSIZE (luai_cast_int(100 * sizeof(luai_TString)))
#endif
/*
** Possible states of the Garbage Collector
*/
#define LUAI_GCSpropagate 0
#define LUAI_GCSatomic 1
#define LUAI_GCSswpallgc 2
#define LUAI_GCSswpfinobj 3
#define LUAI_GCSswptobefnz 4
#define LUAI_GCSswpend 5
#define LUAI_GCScallfin 6
#define LUAI_GCSpause 7
#define luai_issweepphase(g) \
(LUAI_GCSswpallgc <= (g)->gcstate && (g)->gcstate <= LUAI_GCSswpend)
/*
** macro to tell when main invariant (white objects cannot point to black
** ones) must be kept. During a collection, the sweep
** phase may break the invariant, as objects turned white may point to
** still-black objects. The invariant is restored when sweep ends and
** all objects are white again.
*/
#define luai_keepinvariant(g) ((g)->gcstate <= LUAI_GCSatomic)
/*
** some useful bit tricks
*/
#define luai_resetbits(x,m) ((x) &= luai_cast(luai_lu_byte, ~(m)))
#define luai_setbits(x,m) ((x) |= (m))
#define luai_testbits(x,m) ((x) & (m))
#define luai_bitmask(b) (1<<(b))
#define luai_bit2mask(b1,b2) (luai_bitmask(b1) | luai_bitmask(b2))
#define luai_l_setbit(x,b) luai_setbits(x, luai_bitmask(b))
#define luai_resetbit(x,b) luai_resetbits(x, luai_bitmask(b))
#define luai_testbit(x,b) luai_testbits(x, luai_bitmask(b))
/* Layout for bit use in 'marked' luai_field: */
#define LUAI_WHITE0BIT 0 /* object is white (type 0) */
#define LUAI_WHITE1BIT 1 /* object is white (type 1) */
#define LUAI_BLACKBIT 2 /* object is black */
#define LUAI_FINALIZEDBIT 3 /* object has been marked for finalization */
/* bit 7 is currently used by tests (luaL_checkmemory) */
#define LUAI_WHITEBITS luai_bit2mask(LUAI_WHITE0BIT, LUAI_WHITE1BIT)
#define luai_iswhite(x) luai_testbits((x)->marked, LUAI_WHITEBITS)
#define luai_isblack(x) luai_testbit((x)->marked, LUAI_BLACKBIT)
#define luai_isgray(x) /* neither white nor black */ \
(!luai_testbits((x)->marked, LUAI_WHITEBITS | luai_bitmask(LUAI_BLACKBIT)))
#define luai_tofinalize(x) luai_testbit((x)->marked, LUAI_FINALIZEDBIT)
#define luai_otherwhite(g) ((g)->currentwhite ^ LUAI_WHITEBITS)
#define luai_isdeadm(ow,m) (!(((m) ^ LUAI_WHITEBITS) & (ow)))
#define luai_isdead(g,v) luai_isdeadm(luai_otherwhite(g), (v)->marked)
#define luai_changewhite(x) ((x)->marked ^= LUAI_WHITEBITS)
#define luai_gray2black(x) luai_l_setbit((x)->marked, LUAI_BLACKBIT)
#define luaC_white(g) luai_cast(luai_lu_byte, (g)->currentwhite & LUAI_WHITEBITS)
/*
** Does one step of collection when debt becomes positive. 'pre'/'pos'
** allows some adjustments to be done only when needed. macro
** 'luai_condchangemem' is used only for heavy tests (forcing a full
** LUAI_GC cycle on every opportunity)
*/
#define luaC_condGC(L,pre,pos) \
{ if (LUAI_G(L)->LUAI_GCdebt > 0) { pre; luaC_step(L); pos;}; \
luai_condchangemem(L,pre,pos); }
/* more often than not, 'pre'/'pos' are empty */
#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0)
#define luaC_barrier(L,p,v) ( \
(luai_iscollectable(v) && luai_isblack(p) && luai_iswhite(luai_gcvalue(v))) ? \
luaC_barrier_(L,luai_obj2gco(p),luai_gcvalue(v)) : luai_cast_void(0))
#define luaC_barrierback(L,p,v) ( \
(luai_iscollectable(v) && luai_isblack(p) && luai_iswhite(luai_gcvalue(v))) ? \
luaC_barrierback_(L,p) : luai_cast_void(0))
#define luaC_objbarrier(L,p,o) ( \
(luai_isblack(p) && luai_iswhite(o)) ? \
luaC_barrier_(L,luai_obj2gco(p),luai_obj2gco(o)) : luai_cast_void(0))
#define luaC_upvalbarrier(L,uv) ( \
(luai_iscollectable((uv)->v) && !luai_upisopen(uv)) ? \
luaC_upvalbarrier_(L,uv) : luai_cast_void(0))
LUAI_FUNC void luaC_fix (lua_State *L, LUAI_GCObject *o);
LUAI_FUNC void luaC_freeallobjects (lua_State *L);
LUAI_FUNC void luaC_step (lua_State *L);
LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
LUAI_FUNC LUAI_GCObject *luaC_newobj (lua_State *L, int tt, size_t sz);
LUAI_FUNC void luaC_barrier_ (lua_State *L, LUAI_GCObject *o, LUAI_GCObject *v);
LUAI_FUNC void luaC_barrierback_ (lua_State *L, luai_Table *o);
LUAI_FUNC void luaC_upvalbarrier_ (lua_State *L, luai_UpVal *uv);
LUAI_FUNC void luaC_checkfinalizer (lua_State *L, LUAI_GCObject *o, luai_Table *mt);
LUAI_FUNC void luaC_upvdeccount (lua_State *L, luai_UpVal *uv);
/*__lstring.h__*/
#define luai_sizelstring(l) (sizeof(union luai_UTString) + ((l) + 1) * sizeof(char))
#define luai_sizeludata(l) (sizeof(union luai_UUdata) + (l))
#define luai_sizeudata(u) luai_sizeludata((u)->len)
#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \
(sizeof(s)/sizeof(char))-1))
/*
** test whether a string is a reserved word
*/
#define luai_isreserved(s) ((s)->tt == LUA_TSHRSTR && (s)->extra > 0)
/*
** equality for short strings, which are always internalized
*/
#define luai_eqshrstr(a,b) luai_check_exp((a)->tt == LUA_TSHRSTR, (a) == (b))
LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);
LUAI_FUNC unsigned int luaS_hashlongstr (luai_TString *ts);
LUAI_FUNC int luaS_eqlngstr (luai_TString *a, luai_TString *b);
LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
LUAI_FUNC void luaS_clearcache (luai_global_State *g);
LUAI_FUNC void luaS_init (lua_State *L);
LUAI_FUNC void luaS_remove (lua_State *L, luai_TString *ts);
LUAI_FUNC luai_Udata *luaS_newudata (lua_State *L, size_t s);
LUAI_FUNC luai_TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
LUAI_FUNC luai_TString *luaS_new (lua_State *L, const char *str);
LUAI_FUNC luai_TString *luaS_createlngstrobj (lua_State *L, size_t l);
/*__ltable.h__*/
#define luai_gnode(t,i) (&(t)->node[i])
#define luai_gval(n) (&(n)->i_val)
#define luai_gnext(n) ((n)->i_key.nk.luai_next)
/* 'const' to avoid wrong writings that can mess up luai_field 'luai_next' */
#define luai_gkey(n) luai_cast(const luai_TValue*, (&(n)->i_key.tvk))
/*
** writable version of 'luai_gkey'; allows updates to individual fields,
** but not to the whole (which has incompatible type)
*/
#define luai_wgkey(n) (&(n)->i_key.nk)
#define luai_invalidateTMcache(t) ((t)->flags = 0)
/* true when 't' is using 'luai_dummynode' as its hash part */
#define luai_isdummy(t) ((t)->lastfree == NULL)
/* allocated size for hash nodes */
#define luai_allocsizenode(t) (luai_isdummy(t) ? 0 : luai_sizenode(t))
/* returns the key, given the value of a table entry */
#define luai_keyfromval(v) \
(luai_gkey(luai_cast(luai_Node *, luai_cast(char *, (v)) - offsetof(luai_Node, i_val))))
LUAI_FUNC const luai_TValue *luaH_getint (luai_Table *t, lua_Integer key);
LUAI_FUNC void luaH_setint (lua_State *L, luai_Table *t, lua_Integer key,
luai_TValue *value);
LUAI_FUNC const luai_TValue *luaH_getshortstr (luai_Table *t, luai_TString *key);
LUAI_FUNC const luai_TValue *luaH_getstr (luai_Table *t, luai_TString *key);
LUAI_FUNC const luai_TValue *luaH_get (luai_Table *t, const luai_TValue *key);
LUAI_FUNC luai_TValue *luaH_newkey (lua_State *L, luai_Table *t, const luai_TValue *key);
LUAI_FUNC luai_TValue *luaH_set (lua_State *L, luai_Table *t, const luai_TValue *key);
LUAI_FUNC luai_Table *luaH_new (lua_State *L);
LUAI_FUNC void luaH_resize (lua_State *L, luai_Table *t, unsigned int nasize,
unsigned int nhsize);
LUAI_FUNC void luaH_resizearray (lua_State *L, luai_Table *t, unsigned int nasize);
LUAI_FUNC void luaH_free (lua_State *L, luai_Table *t);
LUAI_FUNC int luaH_next (lua_State *L, luai_Table *t, luai_StkId key);
LUAI_FUNC int luaH_getn (luai_Table *t);
#if defined(LUA_DEBUG)
LUAI_FUNC luai_Node *luaH_mainposition (const luai_Table *t, const luai_TValue *key);
LUAI_FUNC int luaH_isdummy (const luai_Table *t);
#endif
/*__lundump.h__*/
/* data to catch conversion errors */
#define LUAC_DATA "\x19\x93\r\n\x1a\n"
#define LUAC_INT 0x5678
#define LUAC_NUM luai_cast_num(370.5)
#define MYINT(s) (s[0]-'0')
#define LUAC_VERSION (MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR))
#define LUAC_FORMAT 0 /* this is the official format */
/* load one chunk; from lundump.c */
LUAI_FUNC luai_LClosure* luaU_undump (lua_State* L, LUAI_ZIO* Z, const char* name);
/* dump one chunk; from ldump.c */
LUAI_FUNC int luaU_dump (lua_State* L, const luai_Proto* f, lua_Writer w,
void* data, int strip);
/*__lvm.h__*/
#if !defined(LUA_NOCVTN2S)
#define luai_cvt2str(o) luai_ttisnumber(o)
#else
#define luai_cvt2str(o) 0 /* no conversion from numbers to strings */
#endif
#if !defined(LUA_NOCVTS2N)
#define luai_cvt2num(o) luai_ttisstring(o)
#else
#define luai_cvt2num(o) 0 /* no conversion from strings to numbers */
#endif
/*
** You can define LUA_FLOORN2I if you want to convert floats to integers
** by flooring them (instead of raising an error if they are not
** integral values)
*/
#if !defined(LUA_FLOORN2I)
#define LUA_FLOORN2I 0
#endif
#define luai_tonumber(o,n) \
(luai_ttisfloat(o) ? (*(n) = luai_fltvalue(o), 1) : luaV_tonumber_(o,n))
#define luai_tointeger(o,i) \
(luai_ttisinteger(o) ? (*(i) = luai_ivalue(o), 1) : luaV_tointeger(o,i,LUA_FLOORN2I))
#define luai_intop(op,v1,v2) luai_l_castU2S(luai_l_castS2U(v1) op luai_l_castS2U(v2))
#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2)
/*
** fast track for 'gettable': if 't' is a table and 't[k]' is not nil,
** return 1 with 'slot' pointing to 't[k]' (final result). Otherwise,
** return 0 (meaning it will have to luai_check metamethod) with 'slot'
** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise).
** 'f' is the raw get function to use.
*/
#define luaV_fastget(L,t,k,slot,f) \
(!luai_ttistable(t) \
? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \
: (slot = f(luai_hvalue(t), k), /* else, do raw access */ \
!luai_ttisnil(slot))) /* result not nil? */
/*
** standard implementation for 'gettable'
*/
#define luaV_gettable(L,t,k,v) { const luai_TValue *slot; \
if (luaV_fastget(L,t,k,slot,luaH_get)) { luai_setobj2s(L, v, slot); } \
else luaV_finishget(L,t,k,v,slot); }
/*
** Fast track for set table. If 't' is a table and 't[k]' is not nil,
** call LUAI_GC barrier, do a raw 't[k]=v', and return true; otherwise,
** return false with 'slot' equal to NULL (if 't' is not a table) or
** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro
** returns true, there is no need to 'luai_invalidateTMcache', because the
** call is not creating a new entry.
*/
#define luaV_fastset(L,t,k,slot,f,v) \
(!luai_ttistable(t) \
? (slot = NULL, 0) \
: (slot = f(luai_hvalue(t), k), \
luai_ttisnil(slot) ? 0 \
: (luaC_barrierback(L, luai_hvalue(t), v), \
luai_setobj2t(L, luai_cast(luai_TValue *,slot), v), \
1)))
#define luaV_settable(L,t,k,v) { const luai_TValue *slot; \
if (!luaV_fastset(L,t,k,slot,luaH_get,v)) \
luaV_finishset(L,t,k,v,slot); }
LUAI_FUNC int luaV_equalobj (lua_State *L, const luai_TValue *t1, const luai_TValue *t2);
LUAI_FUNC int luaV_lessthan (lua_State *L, const luai_TValue *l, const luai_TValue *r);
LUAI_FUNC int luaV_lessequal (lua_State *L, const luai_TValue *l, const luai_TValue *r);
LUAI_FUNC int luaV_tonumber_ (const luai_TValue *obj, lua_Number *n);
LUAI_FUNC int luaV_tointeger (const luai_TValue *obj, lua_Integer *p, int mode);
LUAI_FUNC void luaV_finishget (lua_State *L, const luai_TValue *t, luai_TValue *key,
luai_StkId val, const luai_TValue *slot);
LUAI_FUNC void luaV_finishset (lua_State *L, const luai_TValue *t, luai_TValue *key,
luai_StkId val, const luai_TValue *slot);
LUAI_FUNC void luaV_finishOp (lua_State *L);
LUAI_FUNC void luaV_execute (lua_State *L);
LUAI_FUNC void luaV_concat (lua_State *L, int total);
LUAI_FUNC lua_Integer luaV_div (lua_State *L, lua_Integer x, lua_Integer y);
LUAI_FUNC lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y);
LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y);
LUAI_FUNC void luaV_objlen (lua_State *L, luai_StkId ra, const luai_TValue *rb);
/*__lapi.c__*/
const char lua_ident[] =
"$LuaVersion: " LUA_COPYRIGHT " $"
"$LuaAuthors: " LUA_AUTHORS " $";
/* value at a non-valid index */
#define LUA_NONVALIDVALUE luai_cast(luai_TValue *, luaO_nilobject)
/* corresponding test */
#define lua_isvalid(o) ((o) != luaO_nilobject)
/* test for pseudo index */
#define lua_ispseudo(i) ((i) <= LUA_REGISTRYINDEX)
/* test for upvalue */
#define lua_isupvalue(i) ((i) < LUA_REGISTRYINDEX)
/* test for valid but not pseudo index */
#define lua_isstackindex(i, o) (lua_isvalid(o) && !lua_ispseudo(i))
#define lua_api_checkvalidindex(l,o) luai_api_check(l, lua_isvalid(o), "invalid index")
#define lua_api_checkstackindex(l, i, o) \
luai_api_check(l, lua_isstackindex(i, o), "index not in the stack")
static luai_TValue *lua_index2addr (lua_State *L, int idx) {
luai_CallInfo *ci = L->ci;
if (idx > 0) {
luai_TValue *o = ci->func + idx;
luai_api_check(L, idx <= ci->top - (ci->func + 1), "unacceptable index");
if (o >= L->top) return LUA_NONVALIDVALUE;
else return o;
}
else if (!lua_ispseudo(idx)) { /* negative index */
luai_api_check(L, idx != 0 && -idx <= L->top - (ci->func + 1), "invalid index");
return L->top + idx;
}
else if (idx == LUA_REGISTRYINDEX)
return &LUAI_G(L)->luai_l_registry;
else { /* upvalues */
idx = LUA_REGISTRYINDEX - idx;
luai_api_check(L, idx <= LUAI_MAXUPVAL + 1, "upvalue index too large");
if (luai_ttislcf(ci->func)) /* light C function? */
return LUA_NONVALIDVALUE; /* it has no upvalues */
else {
luai_CClosure *func = luai_clCvalue(ci->func);
return (idx <= func->nupvalues) ? &func->upvalue[idx-1] : LUA_NONVALIDVALUE;
}
}
}
/*
** to be called by 'lua_checkstack' in protected mode, to grow stack
** capturing memory errors
*/
static void lua_growstack (lua_State *L, void *ud) {
int size = *(int *)ud;
luaD_growstack(L, size);
}
LUA_API int lua_checkstack (lua_State *L, int n) {
int res;
luai_CallInfo *ci = L->ci;
lua_lock(L);
luai_api_check(L, n >= 0, "negative 'n'");
if (L->stack_last - L->top > n) /* stack large enough? */
res = 1; /* yes; luai_check is OK */
else { /* no; need to grow stack */
int inuse = luai_cast_int(L->top - L->stack) + LUAI_EXTRA_STACK;
if (inuse > LUAI_MAXSTACK - n) /* can grow without overflow? */
res = 0; /* no */
else /* try to grow stack */
res = (luaD_rawrunprotected(L, &lua_growstack, &n) == LUA_OK);
}
if (res && ci->top < L->top + n)
ci->top = L->top + n; /* adjust frame top */
lua_unlock(L);
return res;
}
LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
int i;
if (from == to) return;
lua_lock(to);
luai_api_checknelems(from, n);
luai_api_check(from, LUAI_G(from) == LUAI_G(to), "moving among independent states");
luai_api_check(from, to->ci->top - to->top >= n, "stack overflow");
from->top -= n;
for (i = 0; i < n; i++) {
luai_setobj2s(to, to->top, from->top + i);
to->top++; /* stack already checked by previous 'luai_api_check' */
}
lua_unlock(to);
}
LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
lua_CFunction old;
lua_lock(L);
old = LUAI_G(L)->panic;
LUAI_G(L)->panic = panicf;
lua_unlock(L);
return old;
}
LUA_API const lua_Number *lua_version (lua_State *L) {
static const lua_Number version = LUA_VERSION_NUM;
if (L == NULL) return &version;
else return LUAI_G(L)->version;
}
/*
** basic stack manipulation
*/
/*
** convert an acceptable stack index into an absolute index
*/
LUA_API int lua_absindex (lua_State *L, int idx) {
return (idx > 0 || lua_ispseudo(idx))
? idx
: luai_cast_int(L->top - L->ci->func) + idx;
}
LUA_API int lua_gettop (lua_State *L) {
return luai_cast_int(L->top - (L->ci->func + 1));
}
LUA_API void lua_settop (lua_State *L, int idx) {
luai_StkId func = L->ci->func;
lua_lock(L);
if (idx >= 0) {
luai_api_check(L, idx <= L->stack_last - (func + 1), "new top too large");
while (L->top < (func + 1) + idx)
luai_setnilvalue(L->top++);
L->top = (func + 1) + idx;
}
else {
luai_api_check(L, -(idx+1) <= (L->top - (func + 1)), "invalid new top");
L->top += idx+1; /* 'subtract' index (index is negative) */
}
lua_unlock(L);
}
/*
** Reverse the stack segment from 'from' to 'to'
** (auxiliary to 'lua_rotate')
*/
static void luai_reverse (lua_State *L, luai_StkId from, luai_StkId to) {
for (; from < to; from++, to--) {
luai_TValue temp;
luai_setobj(L, &temp, from);
luai_setobjs2s(L, from, to);
luai_setobj2s(L, to, &temp);
}
}
/*
** Let x = AB, where A is a prefix of length 'n'. Then,
** rotate x n == BA. But BA == (A^r . B^r)^r.
*/
LUA_API void lua_rotate (lua_State *L, int idx, int n) {
luai_StkId p, t, m;
lua_lock(L);
t = L->top - 1; /* end of stack segment being rotated */
p = lua_index2addr(L, idx); /* start of segment */
lua_api_checkstackindex(L, idx, p);
luai_api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'");
m = (n >= 0 ? t - n : p - n - 1); /* end of prefix */
luai_reverse(L, p, m); /* reverse the prefix with length 'n' */
luai_reverse(L, m + 1, t); /* reverse the suffix */
luai_reverse(L, p, t); /* reverse the entire segment */
lua_unlock(L);
}
LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) {
luai_TValue *fr, *to;
lua_lock(L);
fr = lua_index2addr(L, fromidx);
to = lua_index2addr(L, toidx);
lua_api_checkvalidindex(L, to);
luai_setobj(L, to, fr);
if (lua_isupvalue(toidx)) /* function upvalue? */
luaC_barrier(L, luai_clCvalue(L->ci->func), fr);
/* LUA_REGISTRYINDEX does not need gc barrier
(collector revisits it before finishing collection) */
lua_unlock(L);
}
LUA_API void lua_pushvalue (lua_State *L, int idx) {
lua_lock(L);
luai_setobj2s(L, L->top, lua_index2addr(L, idx));
luai_api_incr_top(L);
lua_unlock(L);
}
/*
** access functions (stack -> C)
*/
LUA_API int lua_type (lua_State *L, int idx) {
luai_StkId o = lua_index2addr(L, idx);
return (lua_isvalid(o) ? luai_ttnov(o) : LUA_TNONE);
}
LUA_API const char *lua_typename (lua_State *L, int t) {
LUAI_UNUSED(L);
luai_api_check(L, LUA_TNONE <= t && t < LUA_NUMTAGS, "invalid tag");
return luai_ttypename(t);
}
LUA_API int lua_iscfunction (lua_State *L, int idx) {
luai_StkId o = lua_index2addr(L, idx);
return (luai_ttislcf(o) || (luai_ttisCclosure(o)));
}
LUA_API int lua_isinteger (lua_State *L, int idx) {
luai_StkId o = lua_index2addr(L, idx);
return luai_ttisinteger(o);
}
LUA_API int lua_isnumber (lua_State *L, int idx) {
lua_Number n;
const luai_TValue *o = lua_index2addr(L, idx);
return luai_tonumber(o, &n);
}
LUA_API int lua_isstring (lua_State *L, int idx) {
const luai_TValue *o = lua_index2addr(L, idx);
return (luai_ttisstring(o) || luai_cvt2str(o));
}
LUA_API int lua_isuserdata (lua_State *L, int idx) {
const luai_TValue *o = lua_index2addr(L, idx);
return (luai_ttisfulluserdata(o) || luai_ttislightuserdata(o));
}
LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
luai_StkId o1 = lua_index2addr(L, index1);
luai_StkId o2 = lua_index2addr(L, index2);
return (lua_isvalid(o1) && lua_isvalid(o2)) ? luaV_rawequalobj(o1, o2) : 0;
}
LUA_API void lua_arith (lua_State *L, int op) {
lua_lock(L);
if (op != LUA_OPUNM && op != LUA_OPBNOT)
luai_api_checknelems(L, 2); /* all other operations expect two operands */
else { /* for unary operations, add fake 2nd operand */
luai_api_checknelems(L, 1);
luai_setobjs2s(L, L->top, L->top - 1);
luai_api_incr_top(L);
}
/* first operand at top - 2, second at top - 1; result go to top - 2 */
luaO_arith(L, op, L->top - 2, L->top - 1, L->top - 2);
L->top--; /* remove second operand */
lua_unlock(L);
}
LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) {
luai_StkId o1, o2;
int i = 0;
lua_lock(L); /* may call tag method */
o1 = lua_index2addr(L, index1);
o2 = lua_index2addr(L, index2);
if (lua_isvalid(o1) && lua_isvalid(o2)) {
switch (op) {
case LUA_OPEQ: i = luaV_equalobj(L, o1, o2); break;
case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break;
case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break;
default: luai_api_check(L, 0, "invalid option");
}
}
lua_unlock(L);
return i;
}
LUA_API size_t lua_stringtonumber (lua_State *L, const char *s) {
size_t sz = luaO_str2num(s, L->top);
if (sz != 0)
luai_api_incr_top(L);
return sz;
}
LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *pisnum) {
lua_Number n;
const luai_TValue *o = lua_index2addr(L, idx);
int isnum = luai_tonumber(o, &n);
if (!isnum)
n = 0; /* call to 'luai_tonumber' may change 'n' even if it fails */
if (pisnum) *pisnum = isnum;
return n;
}
LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *pisnum) {
lua_Integer res;
const luai_TValue *o = lua_index2addr(L, idx);
int isnum = luai_tointeger(o, &res);
if (!isnum)
res = 0; /* call to 'luai_tointeger' may change 'n' even if it fails */
if (pisnum) *pisnum = isnum;
return res;
}
LUA_API int lua_toboolean (lua_State *L, int idx) {
const luai_TValue *o = lua_index2addr(L, idx);
return !luai_l_isfalse(o);
}
LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
luai_StkId o = lua_index2addr(L, idx);
if (!luai_ttisstring(o)) {
if (!luai_cvt2str(o)) { /* not convertible? */
if (len != NULL) *len = 0;
return NULL;
}
lua_lock(L); /* 'luaO_tostring' may create a new string */
luaO_tostring(L, o);
luaC_checkGC(L);
o = lua_index2addr(L, idx); /* previous call may reallocate the stack */
lua_unlock(L);
}
if (len != NULL)
*len = luai_vslen(o);
return luai_svalue(o);
}
LUA_API size_t lua_rawlen (lua_State *L, int idx) {
luai_StkId o = lua_index2addr(L, idx);
switch (luai_ttype(o)) {
case LUA_TSHRSTR: return luai_tsvalue(o)->shrlen;
case LUA_TLNGSTR: return luai_tsvalue(o)->u.lnglen;
case LUA_TUSERDATA: return luai_uvalue(o)->len;
case LUA_TTABLE: return luaH_getn(luai_hvalue(o));
default: return 0;
}
}
LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
luai_StkId o = lua_index2addr(L, idx);
if (luai_ttislcf(o)) return luai_fvalue(o);
else if (luai_ttisCclosure(o))
return luai_clCvalue(o)->f;
else return NULL; /* not a C function */
}
LUA_API void *lua_touserdata (lua_State *L, int idx) {
luai_StkId o = lua_index2addr(L, idx);
switch (luai_ttnov(o)) {
case LUA_TUSERDATA: return luai_getudatamem(luai_uvalue(o));
case LUA_TLIGHTUSERDATA: return luai_pvalue(o);
default: return NULL;
}
}
LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
luai_StkId o = lua_index2addr(L, idx);
return (!luai_ttisthread(o)) ? NULL : luai_thvalue(o);
}
LUA_API const void *lua_topointer (lua_State *L, int idx) {
luai_StkId o = lua_index2addr(L, idx);
switch (luai_ttype(o)) {
case LUA_TTABLE: return luai_hvalue(o);
case LUA_TLCL: return luai_clLvalue(o);
case LUA_TCCL: return luai_clCvalue(o);
case LUA_TLCF: return luai_cast(void *, luai_cast(size_t, luai_fvalue(o)));
case LUA_TTHREAD: return luai_thvalue(o);
case LUA_TUSERDATA: return luai_getudatamem(luai_uvalue(o));
case LUA_TLIGHTUSERDATA: return luai_pvalue(o);
default: return NULL;
}
}
/*
** push functions (C -> stack)
*/
LUA_API void lua_pushnil (lua_State *L) {
lua_lock(L);
luai_setnilvalue(L->top);
luai_api_incr_top(L);
lua_unlock(L);
}
LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
lua_lock(L);
luai_setfltvalue(L->top, n);
luai_api_incr_top(L);
lua_unlock(L);
}
LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
lua_lock(L);
luai_setivalue(L->top, n);
luai_api_incr_top(L);
lua_unlock(L);
}
/*
** Pushes on the stack a string with given length. Avoid using 's' when
** 'len' == 0 (as 's' can be NULL in that case), due to later use of
** 'memcmp' and 'memcpy'.
*/
LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) {
luai_TString *ts;
lua_lock(L);
ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len);
luai_setsvalue2s(L, L->top, ts);
luai_api_incr_top(L);
luaC_checkGC(L);
lua_unlock(L);
return luai_getstr(ts);
}
LUA_API const char *lua_pushstring (lua_State *L, const char *s) {
lua_lock(L);
if (s == NULL)
luai_setnilvalue(L->top);
else {
luai_TString *ts;
ts = luaS_new(L, s);
luai_setsvalue2s(L, L->top, ts);
s = luai_getstr(ts); /* internal copy's address */
}
luai_api_incr_top(L);
luaC_checkGC(L);
lua_unlock(L);
return s;
}
LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
va_list argp) {
const char *ret;
lua_lock(L);
ret = luaO_pushvfstring(L, fmt, argp);
luaC_checkGC(L);
lua_unlock(L);
return ret;
}
LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
const char *ret;
va_list argp;
lua_lock(L);
va_start(argp, fmt);
ret = luaO_pushvfstring(L, fmt, argp);
va_end(argp);
luaC_checkGC(L);
lua_unlock(L);
return ret;
}
LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
lua_lock(L);
if (n == 0) {
luai_setfvalue(L->top, fn);
}
else {
luai_CClosure *cl;
luai_api_checknelems(L, n);
luai_api_check(L, n <= LUAI_MAXUPVAL, "upvalue index too large");
cl = luaF_newCclosure(L, n);
cl->f = fn;
L->top -= n;
while (n--) {
luai_setobj2n(L, &cl->upvalue[n], L->top + n);
/* does not need barrier because closure is white */
}
luai_setclCvalue(L, L->top, cl);
}
luai_api_incr_top(L);
luaC_checkGC(L);
lua_unlock(L);
}
LUA_API void lua_pushboolean (lua_State *L, int b) {
lua_lock(L);
luai_setbvalue(L->top, (b != 0)); /* ensure that true is 1 */
luai_api_incr_top(L);
lua_unlock(L);
}
LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {
lua_lock(L);
luai_setpvalue(L->top, p);
luai_api_incr_top(L);
lua_unlock(L);
}
LUA_API int lua_pushthread (lua_State *L) {
lua_lock(L);
luai_setthvalue(L, L->top, L);
luai_api_incr_top(L);
lua_unlock(L);
return (LUAI_G(L)->mainthread == L);
}
/*
** get functions (Lua -> stack)
*/
static int luai_auxgetstr (lua_State *L, const luai_TValue *t, const char *k) {
const luai_TValue *slot;
luai_TString *str = luaS_new(L, k);
if (luaV_fastget(L, t, str, slot, luaH_getstr)) {
luai_setobj2s(L, L->top, slot);
luai_api_incr_top(L);
}
else {
luai_setsvalue2s(L, L->top, str);
luai_api_incr_top(L);
luaV_finishget(L, t, L->top - 1, L->top - 1, slot);
}
lua_unlock(L);
return luai_ttnov(L->top - 1);
}
LUA_API int lua_getglobal (lua_State *L, const char *name) {
luai_Table *reg = luai_hvalue(&LUAI_G(L)->luai_l_registry);
lua_lock(L);
return luai_auxgetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name);
}
LUA_API int lua_gettable (lua_State *L, int idx) {
luai_StkId t;
lua_lock(L);
t = lua_index2addr(L, idx);
luaV_gettable(L, t, L->top - 1, L->top - 1);
lua_unlock(L);
return luai_ttnov(L->top - 1);
}
LUA_API int lua_getfield (lua_State *L, int idx, const char *k) {
lua_lock(L);
return luai_auxgetstr(L, lua_index2addr(L, idx), k);
}
LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) {
luai_StkId t;
const luai_TValue *slot;
lua_lock(L);
t = lua_index2addr(L, idx);
if (luaV_fastget(L, t, n, slot, luaH_getint)) {
luai_setobj2s(L, L->top, slot);
luai_api_incr_top(L);
}
else {
luai_setivalue(L->top, n);
luai_api_incr_top(L);
luaV_finishget(L, t, L->top - 1, L->top - 1, slot);
}
lua_unlock(L);
return luai_ttnov(L->top - 1);
}
LUA_API int lua_rawget (lua_State *L, int idx) {
luai_StkId t;
lua_lock(L);
t = lua_index2addr(L, idx);
luai_api_check(L, luai_ttistable(t), "table expected");
luai_setobj2s(L, L->top - 1, luaH_get(luai_hvalue(t), L->top - 1));
lua_unlock(L);
return luai_ttnov(L->top - 1);
}
LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) {
luai_StkId t;
lua_lock(L);
t = lua_index2addr(L, idx);
luai_api_check(L, luai_ttistable(t), "table expected");
luai_setobj2s(L, L->top, luaH_getint(luai_hvalue(t), n));
luai_api_incr_top(L);
lua_unlock(L);
return luai_ttnov(L->top - 1);
}
LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) {
luai_StkId t;
luai_TValue k;
lua_lock(L);
t = lua_index2addr(L, idx);
luai_api_check(L, luai_ttistable(t), "table expected");
luai_setpvalue(&k, luai_cast(void *, p));
luai_setobj2s(L, L->top, luaH_get(luai_hvalue(t), &k));
luai_api_incr_top(L);
lua_unlock(L);
return luai_ttnov(L->top - 1);
}
LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
luai_Table *t;
lua_lock(L);
t = luaH_new(L);
luai_sethvalue(L, L->top, t);
luai_api_incr_top(L);
if (narray > 0 || nrec > 0)
luaH_resize(L, t, narray, nrec);
luaC_checkGC(L);
lua_unlock(L);
}
LUA_API int lua_getmetatable (lua_State *L, int objindex) {
const luai_TValue *obj;
luai_Table *mt;
int res = 0;
lua_lock(L);
obj = lua_index2addr(L, objindex);
switch (luai_ttnov(obj)) {
case LUA_TTABLE:
mt = luai_hvalue(obj)->metatable;
break;
case LUA_TUSERDATA:
mt = luai_uvalue(obj)->metatable;
break;
default:
mt = LUAI_G(L)->mt[luai_ttnov(obj)];
break;
}
if (mt != NULL) {
luai_sethvalue(L, L->top, mt);
luai_api_incr_top(L);
res = 1;
}
lua_unlock(L);
return res;
}
LUA_API int lua_getuservalue (lua_State *L, int idx) {
luai_StkId o;
lua_lock(L);
o = lua_index2addr(L, idx);
luai_api_check(L, luai_ttisfulluserdata(o), "full userdata expected");
luai_getuservalue(L, luai_uvalue(o), L->top);
luai_api_incr_top(L);
lua_unlock(L);
return luai_ttnov(L->top - 1);
}
/*
** set functions (stack -> Lua)
*/
/*
** t[k] = value at the top of the stack (where 'k' is a string)
*/
static void luai_auxsetstr (lua_State *L, const luai_TValue *t, const char *k) {
const luai_TValue *slot;
luai_TString *str = luaS_new(L, k);
luai_api_checknelems(L, 1);
if (luaV_fastset(L, t, str, slot, luaH_getstr, L->top - 1))
L->top--; /* pop value */
else {
luai_setsvalue2s(L, L->top, str); /* push 'str' (to make it a luai_TValue) */
luai_api_incr_top(L);
luaV_finishset(L, t, L->top - 1, L->top - 2, slot);
L->top -= 2; /* pop value and key */
}
lua_unlock(L); /* lock done by caller */
}
LUA_API void lua_setglobal (lua_State *L, const char *name) {
luai_Table *reg = luai_hvalue(&LUAI_G(L)->luai_l_registry);
lua_lock(L); /* unlock done in 'luai_auxsetstr' */
luai_auxsetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name);
}
LUA_API void lua_settable (lua_State *L, int idx) {
luai_StkId t;
lua_lock(L);
luai_api_checknelems(L, 2);
t = lua_index2addr(L, idx);
luaV_settable(L, t, L->top - 2, L->top - 1);
L->top -= 2; /* pop index and value */
lua_unlock(L);
}
LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
lua_lock(L); /* unlock done in 'luai_auxsetstr' */
luai_auxsetstr(L, lua_index2addr(L, idx), k);
}
LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) {
luai_StkId t;
const luai_TValue *slot;
lua_lock(L);
luai_api_checknelems(L, 1);
t = lua_index2addr(L, idx);
if (luaV_fastset(L, t, n, slot, luaH_getint, L->top - 1))
L->top--; /* pop value */
else {
luai_setivalue(L->top, n);
luai_api_incr_top(L);
luaV_finishset(L, t, L->top - 1, L->top - 2, slot);
L->top -= 2; /* pop value and key */
}
lua_unlock(L);
}
LUA_API void lua_rawset (lua_State *L, int idx) {
luai_StkId o;
luai_TValue *slot;
lua_lock(L);
luai_api_checknelems(L, 2);
o = lua_index2addr(L, idx);
luai_api_check(L, luai_ttistable(o), "table expected");
slot = luaH_set(L, luai_hvalue(o), L->top - 2);
luai_setobj2t(L, slot, L->top - 1);
luai_invalidateTMcache(luai_hvalue(o));
luaC_barrierback(L, luai_hvalue(o), L->top-1);
L->top -= 2;
lua_unlock(L);
}
LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) {
luai_StkId o;
lua_lock(L);
luai_api_checknelems(L, 1);
o = lua_index2addr(L, idx);
luai_api_check(L, luai_ttistable(o), "table expected");
luaH_setint(L, luai_hvalue(o), n, L->top - 1);
luaC_barrierback(L, luai_hvalue(o), L->top-1);
L->top--;
lua_unlock(L);
}
LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {
luai_StkId o;
luai_TValue k, *slot;
lua_lock(L);
luai_api_checknelems(L, 1);
o = lua_index2addr(L, idx);
luai_api_check(L, luai_ttistable(o), "table expected");
luai_setpvalue(&k, luai_cast(void *, p));
slot = luaH_set(L, luai_hvalue(o), &k);
luai_setobj2t(L, slot, L->top - 1);
luaC_barrierback(L, luai_hvalue(o), L->top - 1);
L->top--;
lua_unlock(L);
}
LUA_API int lua_setmetatable (lua_State *L, int objindex) {
luai_TValue *obj;
luai_Table *mt;
lua_lock(L);
luai_api_checknelems(L, 1);
obj = lua_index2addr(L, objindex);
if (luai_ttisnil(L->top - 1))
mt = NULL;
else {
luai_api_check(L, luai_ttistable(L->top - 1), "table expected");
mt = luai_hvalue(L->top - 1);
}
switch (luai_ttnov(obj)) {
case LUA_TTABLE: {
luai_hvalue(obj)->metatable = mt;
if (mt) {
luaC_objbarrier(L, luai_gcvalue(obj), mt);
luaC_checkfinalizer(L, luai_gcvalue(obj), mt);
}
break;
}
case LUA_TUSERDATA: {
luai_uvalue(obj)->metatable = mt;
if (mt) {
luaC_objbarrier(L, luai_uvalue(obj), mt);
luaC_checkfinalizer(L, luai_gcvalue(obj), mt);
}
break;
}
default: {
LUAI_G(L)->mt[luai_ttnov(obj)] = mt;
break;
}
}
L->top--;
lua_unlock(L);
return 1;
}
LUA_API void lua_setuservalue (lua_State *L, int idx) {
luai_StkId o;
lua_lock(L);
luai_api_checknelems(L, 1);
o = lua_index2addr(L, idx);
luai_api_check(L, luai_ttisfulluserdata(o), "full userdata expected");
luai_setuservalue(L, luai_uvalue(o), L->top - 1);
luaC_barrier(L, luai_gcvalue(o), L->top - 1);
L->top--;
lua_unlock(L);
}
/*
** 'load' and 'call' functions (run Lua code)
*/
#define lua_checkresults(L,na,nr) \
luai_api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)), \
"results from function overflow current stack size")
LUA_API void lua_callk (lua_State *L, int nargs, int nresults,
lua_KContext ctx, lua_KFunction k) {
luai_StkId func;
lua_lock(L);
luai_api_check(L, k == NULL || !luai_isLua(L->ci),
"cannot use continuations inside hooks");
luai_api_checknelems(L, nargs+1);
luai_api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
lua_checkresults(L, nargs, nresults);
func = L->top - (nargs+1);
if (k != NULL && L->nny == 0) { /* need to prepare continuation? */
L->ci->u.c.k = k; /* luai_save continuation */
L->ci->u.c.ctx = ctx; /* luai_save context */
luaD_call(L, func, nresults); /* do the call */
}
else /* no continuation or no yieldable */
luaD_callnoyield(L, func, nresults); /* just do the call */
luai_adjustresults(L, nresults);
lua_unlock(L);
}
/*
** Execute a protected call.
*/
struct CallS { /* data to 'luai_f_call' */
luai_StkId func;
int nresults;
};
static void luai_f_call (lua_State *L, void *ud) {
struct CallS *c = luai_cast(struct CallS *, ud);
luaD_callnoyield(L, c->func, c->nresults);
}
LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
lua_KContext ctx, lua_KFunction k) {
struct CallS c;
int status;
ptrdiff_t func;
lua_lock(L);
luai_api_check(L, k == NULL || !luai_isLua(L->ci),
"cannot use continuations inside hooks");
luai_api_checknelems(L, nargs+1);
luai_api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
lua_checkresults(L, nargs, nresults);
if (errfunc == 0)
func = 0;
else {
luai_StkId o = lua_index2addr(L, errfunc);
lua_api_checkstackindex(L, errfunc, o);
func = luai_savestack(L, o);
}
c.func = L->top - (nargs+1); /* function to be called */
if (k == NULL || L->nny > 0) { /* no continuation or no yieldable? */
c.nresults = nresults; /* do a 'conventional' protected call */
status = luaD_pcall(L, luai_f_call, &c, luai_savestack(L, c.func), func);
}
else { /* prepare continuation (call is already protected by 'luai_resume') */
luai_CallInfo *ci = L->ci;
ci->u.c.k = k; /* luai_save continuation */
ci->u.c.ctx = ctx; /* luai_save context */
/* luai_save information for error recovery */
ci->extra = luai_savestack(L, c.func);
ci->u.c.old_errfunc = L->errfunc;
L->errfunc = func;
luai_setoah(ci->callstatus, L->allowhook); /* luai_save value of 'allowhook' */
ci->callstatus |= LUAI_CIST_YPCALL; /* function can do error recovery */
luaD_call(L, c.func, nresults); /* do the call */
ci->callstatus &= ~LUAI_CIST_YPCALL;
L->errfunc = ci->u.c.old_errfunc;
status = LUA_OK; /* if it is here, there were no errors */
}
luai_adjustresults(L, nresults);
lua_unlock(L);
return status;
}
LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
const char *chunkname, const char *mode) {
LUAI_ZIO z;
int status;
lua_lock(L);
if (!chunkname) chunkname = "?";
luaZ_init(L, &z, reader, data);
status = luaD_protectedparser(L, &z, chunkname, mode);
if (status == LUA_OK) { /* no errors? */
luai_LClosure *f = luai_clLvalue(L->top - 1); /* get newly created function */
if (f->nupvalues >= 1) { /* does it have an upvalue? */
/* get global table from registry */
luai_Table *reg = luai_hvalue(&LUAI_G(L)->luai_l_registry);
const luai_TValue *gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
/* set global table as 1st upvalue of 'f' (may be LUA_ENV) */
luai_setobj(L, f->upvals[0]->v, gt);
luaC_upvalbarrier(L, f->upvals[0]);
}
}
lua_unlock(L);
return status;
}
LUA_API int lua_dump (lua_State *L, lua_Writer luai_writer, void *data, int strip) {
int status;
luai_TValue *o;
lua_lock(L);
luai_api_checknelems(L, 1);
o = L->top - 1;
if (luai_isLfunction(o))
status = luaU_dump(L, luai_getproto(o), luai_writer, data, strip);
else
status = 1;
lua_unlock(L);
return status;
}
LUA_API int lua_status (lua_State *L) {
return L->status;
}
/*
** Garbage-collection function
*/
LUA_API int lua_gc (lua_State *L, int what, int data) {
int res = 0;
luai_global_State *g;
lua_lock(L);
g = LUAI_G(L);
switch (what) {
case LUA_GCSTOP: {
g->gcrunning = 0;
break;
}
case LUA_GCRESTART: {
luaE_setdebt(g, 0);
g->gcrunning = 1;
break;
}
case LUA_GCCOLLECT: {
luaC_fullgc(L, 0);
break;
}
case LUA_GCCOUNT: {
/* LUAI_GC values are expressed in Kbytes: #bytes/2^10 */
res = luai_cast_int(luai_gettotalbytes(g) >> 10);
break;
}
case LUA_GCCOUNTB: {
res = luai_cast_int(luai_gettotalbytes(g) & 0x3ff);
break;
}
case LUA_GCSTEP: {
luai_l_mem debt = 1; /* =1 to signal that it did an actual step */
luai_lu_byte oldrunning = g->gcrunning;
g->gcrunning = 1; /* allow LUAI_GC to run */
if (data == 0) {
luaE_setdebt(g, -LUA_GCSTEPSIZE); /* to do a "small" step */
luaC_step(L);
}
else { /* add 'data' to total debt */
debt = luai_cast(luai_l_mem, data) * 1024 + g->LUAI_GCdebt;
luaE_setdebt(g, debt);
luaC_checkGC(L);
}
g->gcrunning = oldrunning; /* restore previous state */
if (debt > 0 && g->gcstate == LUAI_GCSpause) /* end of cycle? */
res = 1; /* signal it */
break;
}
case LUA_GCSETPAUSE: {
res = g->gcpause;
g->gcpause = data;
break;
}
case LUA_GCSETSTEPMUL: {
res = g->gcstepmul;
if (data < 40) data = 40; /* avoid ridiculous low values (and 0) */
g->gcstepmul = data;
break;
}
case LUA_GCISRUNNING: {
res = g->gcrunning;
break;
}
default: res = -1; /* invalid option */
}
lua_unlock(L);
return res;
}
/*
** miscellaneous functions
*/
LUA_API int lua_error (lua_State *L) {
lua_lock(L);
luai_api_checknelems(L, 1);
luaG_errormsg(L);
/* code unreachable; will unlock when control actually leaves the kernel */
return 0; /* to avoid warnings */
}
LUA_API int lua_next (lua_State *L, int idx) {
luai_StkId t;
int more;
lua_lock(L);
t = lua_index2addr(L, idx);
luai_api_check(L, luai_ttistable(t), "table expected");
more = luaH_next(L, luai_hvalue(t), L->top - 1);
if (more) {
luai_api_incr_top(L);
}
else /* no more elements */
L->top -= 1; /* remove key */
lua_unlock(L);
return more;
}
LUA_API void lua_concat (lua_State *L, int n) {
lua_lock(L);
luai_api_checknelems(L, n);
if (n >= 2) {
luaV_concat(L, n);
}
else if (n == 0) { /* push empty string */
luai_setsvalue2s(L, L->top, luaS_newlstr(L, "", 0));
luai_api_incr_top(L);
}
/* else n == 1; nothing to do */
luaC_checkGC(L);
lua_unlock(L);
}
LUA_API void lua_len (lua_State *L, int idx) {
luai_StkId t;
lua_lock(L);
t = lua_index2addr(L, idx);
luaV_objlen(L, L->top, t);
luai_api_incr_top(L);
lua_unlock(L);
}
LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) {
lua_Alloc f;
lua_lock(L);
if (ud) *ud = LUAI_G(L)->ud;
f = LUAI_G(L)->frealloc;
lua_unlock(L);
return f;
}
LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) {
lua_lock(L);
LUAI_G(L)->ud = ud;
LUAI_G(L)->frealloc = f;
lua_unlock(L);
}
LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
luai_Udata *u;
lua_lock(L);
u = luaS_newudata(L, size);
luai_setuvalue(L, L->top, u);
luai_api_incr_top(L);
luaC_checkGC(L);
lua_unlock(L);
return luai_getudatamem(u);
}
static const char *luai_aux_upvalue (luai_StkId fi, int n, luai_TValue **val,
luai_CClosure **owner, luai_UpVal **uv) {
switch (luai_ttype(fi)) {
case LUA_TCCL: { /* C closure */
luai_CClosure *f = luai_clCvalue(fi);
if (!(1 <= n && n <= f->nupvalues)) return NULL;
*val = &f->upvalue[n-1];
if (owner) *owner = f;
return "";
}
case LUA_TLCL: { /* Lua closure */
luai_LClosure *f = luai_clLvalue(fi);
luai_TString *name;
luai_Proto *p = f->p;
if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
*val = f->upvals[n-1]->v;
if (uv) *uv = f->upvals[n - 1];
name = p->upvalues[n-1].name;
return (name == NULL) ? "(*no name)" : luai_getstr(name);
}
default: return NULL; /* not a closure */
}
}
LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
const char *name;
luai_TValue *val = NULL; /* to avoid warnings */
lua_lock(L);
name = luai_aux_upvalue(lua_index2addr(L, funcindex), n, &val, NULL, NULL);
if (name) {
luai_setobj2s(L, L->top, val);
luai_api_incr_top(L);
}
lua_unlock(L);
return name;
}
LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
const char *name;
luai_TValue *val = NULL; /* to avoid warnings */
luai_CClosure *owner = NULL;
luai_UpVal *uv = NULL;
luai_StkId fi;
lua_lock(L);
fi = lua_index2addr(L, funcindex);
luai_api_checknelems(L, 1);
name = luai_aux_upvalue(fi, n, &val, &owner, &uv);
if (name) {
L->top--;
luai_setobj(L, val, L->top);
if (owner) { luaC_barrier(L, owner, L->top); }
else if (uv) { luaC_upvalbarrier(L, uv); }
}
lua_unlock(L);
return name;
}
static luai_UpVal **luai_getupvalref (lua_State *L, int fidx, int n, luai_LClosure **pf) {
luai_LClosure *f;
luai_StkId fi = lua_index2addr(L, fidx);
luai_api_check(L, luai_ttisLclosure(fi), "Lua function expected");
f = luai_clLvalue(fi);
luai_api_check(L, (1 <= n && n <= f->p->sizeupvalues), "invalid upvalue index");
if (pf) *pf = f;
return &f->upvals[n - 1]; /* get its upvalue pointer */
}
LUA_API void *lua_upvalueid (lua_State *L, int fidx, int n) {
luai_StkId fi = lua_index2addr(L, fidx);
switch (luai_ttype(fi)) {
case LUA_TLCL: { /* lua closure */
return *luai_getupvalref(L, fidx, n, NULL);
}
case LUA_TCCL: { /* C closure */
luai_CClosure *f = luai_clCvalue(fi);
luai_api_check(L, 1 <= n && n <= f->nupvalues, "invalid upvalue index");
return &f->upvalue[n - 1];
}
default: {
luai_api_check(L, 0, "closure expected");
return NULL;
}
}
}
LUA_API void lua_upvaluejoin (lua_State *L, int fidx1, int n1,
int fidx2, int n2) {
luai_LClosure *f1;
luai_UpVal **up1 = luai_getupvalref(L, fidx1, n1, &f1);
luai_UpVal **up2 = luai_getupvalref(L, fidx2, n2, NULL);
luaC_upvdeccount(L, *up1);
*up1 = *up2;
(*up1)->refcount++;
if (luai_upisopen(*up1)) (*up1)->u.open.touched = 1;
luaC_upvalbarrier(L, *up1);
}
/*__lauxlib.c__*/
/*
** {======================================================
** Traceback
** =======================================================
*/
#define LUA_LEVELS1 10 /* size of the first part of the stack */
#define LUA_LEVELS2 11 /* size of the second part of the stack */
/*
** search for 'objidx' in table at index -1.
** return 1 + string at top if find a good name.
*/
static int luai_findfield (lua_State *L, int objidx, int level) {
if (level == 0 || !lua_istable(L, -1))
return 0; /* not found */
lua_pushnil(L); /* start 'luai_next' loop */
while (lua_next(L, -2)) { /* for each pair in table */
if (lua_type(L, -2) == LUA_TSTRING) { /* ignore non-string keys */
if (lua_rawequal(L, objidx, -1)) { /* found object? */
lua_pop(L, 1); /* remove value (but keep name) */
return 1;
}
else if (luai_findfield(L, objidx, level - 1)) { /* try recursively */
lua_remove(L, -2); /* remove table (but keep name) */
lua_pushliteral(L, ".");
lua_insert(L, -2); /* place '.' between the two names */
lua_concat(L, 3);
return 1;
}
}
lua_pop(L, 1); /* remove value */
}
return 0; /* not found */
}
/*
** Search for a name for a function in all loaded modules
*/
static int luai_pushglobalfuncname (lua_State *L, lua_Debug *ar) {
int top = lua_gettop(L);
lua_getinfo(L, "f", ar); /* push function */
lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
if (luai_findfield(L, top + 1, 2)) {
const char *name = lua_tostring(L, -1);
if (strncmp(name, "_G.", 3) == 0) { /* name start with '_G.'? */
lua_pushstring(L, name + 3); /* push name without prefix */
lua_remove(L, -2); /* remove original name */
}
lua_copy(L, -1, top + 1); /* move name to proper place */
lua_pop(L, 2); /* remove pushed values */
return 1;
}
else {
lua_settop(L, top); /* remove function and global table */
return 0;
}
}
static void luai_pushfuncname (lua_State *L, lua_Debug *ar) {
if (luai_pushglobalfuncname(L, ar)) { /* try first a global name */
lua_pushfstring(L, "function '%s'", lua_tostring(L, -1));
lua_remove(L, -2); /* remove name */
}
else if (*ar->namewhat != '\0') /* is there a name from code? */
lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name); /* use it */
else if (*ar->what == 'm') /* main? */
lua_pushliteral(L, "main chunk");
else if (*ar->what != 'C') /* for Lua functions, use <file:line> */
lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
else /* nothing left... */
lua_pushliteral(L, "?");
}
static int luai_lastlevel (lua_State *L) {
lua_Debug ar;
int li = 1, le = 1;
/* find an upper bound */
while (lua_getstack(L, le, &ar)) { li = le; le *= 2; }
/* do a binary search */
while (li < le) {
int m = (li + le)/2;
if (lua_getstack(L, m, &ar)) li = m + 1;
else le = m;
}
return le - 1;
}
LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1,
const char *msg, int level) {
lua_Debug ar;
int top = lua_gettop(L);
int last = luai_lastlevel(L1);
int n1 = (last - level > LUA_LEVELS1 + LUA_LEVELS2) ? LUA_LEVELS1 : -1;
if (msg)
lua_pushfstring(L, "%s\n", msg);
luaL_checkstack(L, 10, NULL);
lua_pushliteral(L, "stack traceback:");
while (lua_getstack(L1, level++, &ar)) {
if (n1-- == 0) { /* too many levels? */
lua_pushliteral(L, "\n\t..."); /* add a '...' */
level = last - LUA_LEVELS2 + 1; /* and skip to last ones */
}
else {
lua_getinfo(L1, "Slnt", &ar);
lua_pushfstring(L, "\n\t%s:", ar.short_src);
if (ar.luai_currentline > 0)
lua_pushfstring(L, "%d:", ar.luai_currentline);
lua_pushliteral(L, " in ");
luai_pushfuncname(L, &ar);
if (ar.istailcall)
lua_pushliteral(L, "\n\t(...tail calls...)");
lua_concat(L, lua_gettop(L) - top);
}
}
lua_concat(L, lua_gettop(L) - top);
}
/* }====================================================== */
/*
** {======================================================
** Error-report functions
** =======================================================
*/
LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) {
lua_Debug ar;
if (!lua_getstack(L, 0, &ar)) /* no stack frame? */
return luaL_error(L, "bad argument #%d (%s)", arg, extramsg);
lua_getinfo(L, "n", &ar);
if (strcmp(ar.namewhat, "method") == 0) {
arg--; /* do not count 'self' */
if (arg == 0) /* error is in the self argument itself? */
return luaL_error(L, "calling '%s' on bad self (%s)",
ar.name, extramsg);
}
if (ar.name == NULL)
ar.name = (luai_pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?";
return luaL_error(L, "bad argument #%d to '%s' (%s)",
arg, ar.name, extramsg);
}
static int luai_typeerror (lua_State *L, int arg, const char *tname) {
const char *msg;
const char *typearg; /* name for the type of the actual argument */
if (luaL_getmetafield(L, arg, "__name") == LUA_TSTRING)
typearg = lua_tostring(L, -1); /* use the given type name */
else if (lua_type(L, arg) == LUA_TLIGHTUSERDATA)
typearg = "light userdata"; /* special name for messages */
else
typearg = luaL_typename(L, arg); /* standard name */
msg = lua_pushfstring(L, "%s expected, got %s", tname, typearg);
return luaL_argerror(L, arg, msg);
}
static void luai_tagerror (lua_State *L, int arg, int tag) {
luai_typeerror(L, arg, lua_typename(L, tag));
}
/*
** The use of 'lua_pushfstring' ensures this function does not
** need reserved stack space when called.
*/
LUALIB_API void luaL_where (lua_State *L, int level) {
lua_Debug ar;
if (lua_getstack(L, level, &ar)) { /* luai_check function at level */
lua_getinfo(L, "Sl", &ar); /* get info about it */
if (ar.luai_currentline > 0) { /* is there info? */
lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.luai_currentline);
return;
}
}
lua_pushfstring(L, ""); /* else, no information available... */
}
/*
** Again, the use of 'lua_pushvfstring' ensures this function does
** not need reserved stack space when called. (At worst, it generates
** an error with "stack overflow" instead of the given message.)
*/
LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
va_list argp;
va_start(argp, fmt);
luaL_where(L, 1);
lua_pushvfstring(L, fmt, argp);
va_end(argp);
lua_concat(L, 2);
return lua_error(L);
}
LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) {
int en = errno; /* calls to Lua API may change this value */
if (stat) {
lua_pushboolean(L, 1);
return 1;
}
else {
lua_pushnil(L);
if (fname)
lua_pushfstring(L, "%s: %s", fname, strerror(en));
else
lua_pushstring(L, strerror(en));
lua_pushinteger(L, en);
return 3;
}
}
#if !defined(luai_l_inspectstat) /* { */
#if defined(LUA_USE_POSIX)
#include <sys/wait.h>
/*
** use appropriate macros to interpret 'pclose' return status
*/
#define luai_l_inspectstat(stat,what) \
if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \
else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; }
#else
#define luai_l_inspectstat(stat,what) /* no op */
#endif
#endif /* } */
LUALIB_API int luaL_execresult (lua_State *L, int stat) {
const char *what = "exit"; /* type of termination */
if (stat == -1) /* error? */
return luaL_fileresult(L, 0, NULL);
else {
luai_l_inspectstat(stat, what); /* interpret result */
if (*what == 'e' && stat == 0) /* successful termination? */
lua_pushboolean(L, 1);
else
lua_pushnil(L);
lua_pushstring(L, what);
lua_pushinteger(L, stat);
return 3; /* return true/nil,what,code */
}
}
/* }====================================================== */
/*
** {======================================================
** Userdata's metatable manipulation
** =======================================================
*/
LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */
return 0; /* leave previous value on top, but return 0 */
lua_pop(L, 1);
lua_createtable(L, 0, 2); /* create metatable */
lua_pushstring(L, tname);
lua_setfield(L, -2, "__name"); /* metatable.__name = tname */
lua_pushvalue(L, -1);
lua_setfield(L, LUA_REGISTRYINDEX, tname); /* registry.name = metatable */
return 1;
}
LUALIB_API void luaL_setmetatable (lua_State *L, const char *tname) {
luaL_getmetatable(L, tname);
lua_setmetatable(L, -2);
}
LUALIB_API void *luaL_testudata (lua_State *L, int ud, const char *tname) {
void *p = lua_touserdata(L, ud);
if (p != NULL) { /* value is a userdata? */
if (lua_getmetatable(L, ud)) { /* does it have a metatable? */
luaL_getmetatable(L, tname); /* get correct metatable */
if (!lua_rawequal(L, -1, -2)) /* not the same? */
p = NULL; /* value is a userdata with wrong metatable */
lua_pop(L, 2); /* remove both metatables */
return p;
}
}
return NULL; /* value is not a userdata with a metatable */
}
LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
void *p = luaL_testudata(L, ud, tname);
if (p == NULL) luai_typeerror(L, ud, tname);
return p;
}
/* }====================================================== */
/*
** {======================================================
** Argument luai_check functions
** =======================================================
*/
LUALIB_API int luaL_checkoption (lua_State *L, int arg, const char *def,
const char *const lst[]) {
const char *name = (def) ? luaL_optstring(L, arg, def) :
luaL_checkstring(L, arg);
int i;
for (i=0; lst[i]; i++)
if (strcmp(lst[i], name) == 0)
return i;
return luaL_argerror(L, arg,
lua_pushfstring(L, "invalid option '%s'", name));
}
/*
** Ensures the stack has at least 'space' extra slots, raising an error
** if it cannot fulfill the request. (The error handling needs a few
** extra slots to format the error message. In case of an error without
** this extra space, Lua will generate the same 'stack overflow' error,
** but without 'msg'.)
*/
LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) {
if (!lua_checkstack(L, space)) {
if (msg)
luaL_error(L, "stack overflow (%s)", msg);
else
luaL_error(L, "stack overflow");
}
}
LUALIB_API void luaL_checktype (lua_State *L, int arg, int t) {
if (lua_type(L, arg) != t)
luai_tagerror(L, arg, t);
}
LUALIB_API void luaL_checkany (lua_State *L, int arg) {
if (lua_type(L, arg) == LUA_TNONE)
luaL_argerror(L, arg, "value expected");
}
LUALIB_API const char *luaL_checklstring (lua_State *L, int arg, size_t *len) {
const char *s = lua_tolstring(L, arg, len);
if (!s) luai_tagerror(L, arg, LUA_TSTRING);
return s;
}
LUALIB_API const char *luaL_optlstring (lua_State *L, int arg,
const char *def, size_t *len) {
if (lua_isnoneornil(L, arg)) {
if (len)
*len = (def ? strlen(def) : 0);
return def;
}
else return luaL_checklstring(L, arg, len);
}
LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) {
int isnum;
lua_Number d = lua_tonumberx(L, arg, &isnum);
if (!isnum)
luai_tagerror(L, arg, LUA_TNUMBER);
return d;
}
LUALIB_API lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number def) {
return luaL_opt(L, luaL_checknumber, arg, def);
}
static void luai_interror (lua_State *L, int arg) {
if (lua_isnumber(L, arg))
luaL_argerror(L, arg, "number has no integer representation");
else
luai_tagerror(L, arg, LUA_TNUMBER);
}
LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) {
int isnum;
lua_Integer d = lua_tointegerx(L, arg, &isnum);
if (!isnum) {
luai_interror(L, arg);
}
return d;
}
LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg,
lua_Integer def) {
return luaL_opt(L, luaL_checkinteger, arg, def);
}
/* }====================================================== */
/*
** {======================================================
** Generic Buffer manipulation
** =======================================================
*/
/* userdata to box arbitrary data */
typedef struct luai_UBox {
void *box;
size_t bsize;
} luai_UBox;
static void *luai_resizebox (lua_State *L, int idx, size_t newsize) {
void *ud;
lua_Alloc allocf = lua_getallocf(L, &ud);
luai_UBox *box = (luai_UBox *)lua_touserdata(L, idx);
void *temp = allocf(ud, box->box, box->bsize, newsize);
if (temp == NULL && newsize > 0) { /* allocation error? */
luai_resizebox(L, idx, 0); /* free buffer */
luaL_error(L, "not enough memory for buffer allocation");
}
box->box = temp;
box->bsize = newsize;
return temp;
}
static int luai_boxgc (lua_State *L) {
luai_resizebox(L, 1, 0);
return 0;
}
static void *luai_newbox (lua_State *L, size_t newsize) {
luai_UBox *box = (luai_UBox *)lua_newuserdata(L, sizeof(luai_UBox));
box->box = NULL;
box->bsize = 0;
if (luaL_newmetatable(L, "LUABOX")) { /* creating metatable? */
lua_pushcfunction(L, luai_boxgc);
lua_setfield(L, -2, "__gc"); /* metatable.__gc = luai_boxgc */
}
lua_setmetatable(L, -2);
return luai_resizebox(L, -1, newsize);
}
/*
** luai_check whether buffer is using a userdata on the stack as a temporary
** buffer
*/
#define lua_buffonstack(B) ((B)->b != (B)->initb)
/*
** returns a pointer to a free area with at least 'sz' bytes
*/
LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {
lua_State *L = B->L;
if (B->size - B->n < sz) { /* not enough space? */
char *newbuff;
size_t newsize = B->size * 2; /* double buffer size */
if (newsize - B->n < sz) /* not big enough? */
newsize = B->n + sz;
if (newsize < B->n || newsize - B->n < sz)
luaL_error(L, "buffer too large");
/* create larger buffer */
if (lua_buffonstack(B))
newbuff = (char *)luai_resizebox(L, -1, newsize);
else { /* no buffer yet */
newbuff = (char *)luai_newbox(L, newsize);
memcpy(newbuff, B->b, B->n * sizeof(char)); /* copy original content */
}
B->b = newbuff;
B->size = newsize;
}
return &B->b[B->n];
}
LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
if (l > 0) { /* avoid 'memcpy' when 's' can be NULL */
char *b = luaL_prepbuffsize(B, l);
memcpy(b, s, l * sizeof(char));
luaL_addsize(B, l);
}
}
LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {
luaL_addlstring(B, s, strlen(s));
}
LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
lua_State *L = B->L;
lua_pushlstring(L, B->b, B->n);
if (lua_buffonstack(B)) {
luai_resizebox(L, -2, 0); /* delete old buffer */
lua_remove(L, -2); /* remove its header from the stack */
}
}
LUALIB_API void luaL_pushresultsize (luaL_Buffer *B, size_t sz) {
luaL_addsize(B, sz);
luaL_pushresult(B);
}
LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
lua_State *L = B->L;
size_t l;
const char *s = lua_tolstring(L, -1, &l);
if (lua_buffonstack(B))
lua_insert(L, -2); /* put value below buffer */
luaL_addlstring(B, s, l);
lua_remove(L, (lua_buffonstack(B)) ? -2 : -1); /* remove value */
}
LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
B->L = L;
B->b = B->initb;
B->n = 0;
B->size = LUAL_BUFFERSIZE;
}
LUALIB_API char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz) {
luaL_buffinit(L, B);
return luaL_prepbuffsize(B, sz);
}
/* }====================================================== */
/*
** {======================================================
** Reference system
** =======================================================
*/
/* index of free-list header */
#define lua_freelist 0
LUALIB_API int luaL_ref (lua_State *L, int t) {
int ref;
if (lua_isnil(L, -1)) {
lua_pop(L, 1); /* remove from stack */
return LUA_REFNIL; /* 'nil' has a unique fixed reference */
}
t = lua_absindex(L, t);
lua_rawgeti(L, t, lua_freelist); /* get first free element */
ref = (int)lua_tointeger(L, -1); /* ref = t[lua_freelist] */
lua_pop(L, 1); /* remove it from stack */
if (ref != 0) { /* any free element? */
lua_rawgeti(L, t, ref); /* remove it luai_list */
lua_rawseti(L, t, lua_freelist); /* (t[lua_freelist] = t[ref]) */
}
else /* no free elements */
ref = (int)lua_rawlen(L, t) + 1; /* get a new reference */
lua_rawseti(L, t, ref);
return ref;
}
LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
if (ref >= 0) {
t = lua_absindex(L, t);
lua_rawgeti(L, t, lua_freelist);
lua_rawseti(L, t, ref); /* t[ref] = t[lua_freelist] */
lua_pushinteger(L, ref);
lua_rawseti(L, t, lua_freelist); /* t[lua_freelist] = ref */
}
}
/* }====================================================== */
/*
** {======================================================
** Load functions
** =======================================================
*/
typedef struct luai_LoadF {
int n; /* number of pre-read characters */
FILE *f; /* file being read */
char buff[BUFSIZ]; /* area for reading file */
} luai_LoadF;
static const char *luai_getF (lua_State *L, void *ud, size_t *size) {
luai_LoadF *lf = (luai_LoadF *)ud;
(void)L; /* not used */
if (lf->n > 0) { /* are there pre-read characters to be read? */
*size = lf->n; /* return them (chars already in buffer) */
lf->n = 0; /* no more pre-read characters */
}
else { /* read a luai_getblock from file */
/* 'fread' can return > 0 *and* set the EOF flag. If luai_next call to
'luai_getF' called 'fread', it might still wait for user input.
The luai_next luai_check avoids this problem. */
if (feof(lf->f)) return NULL;
*size = fread(lf->buff, 1, sizeof(lf->buff), lf->f); /* read luai_getblock */
}
return lf->buff;
}
static int luai_errfile (lua_State *L, const char *what, int fnameindex) {
const char *serr = strerror(errno);
const char *filename = lua_tostring(L, fnameindex) + 1;
lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
lua_remove(L, fnameindex);
return LUA_ERRFILE;
}
static int luai_skipBOM (luai_LoadF *lf) {
const char *p = "\xEF\xBB\xBF"; /* UTF-8 BOM mark */
int c;
lf->n = 0;
do {
c = getc(lf->f);
if (c == EOF || c != *(const unsigned char *)p++) return c;
lf->buff[lf->n++] = c; /* to be read by the parser */
} while (*p != '\0');
lf->n = 0; /* prefix matched; discard it */
return getc(lf->f); /* return luai_next character */
}
/*
** reads the first character of file 'f' and skips an optional BOM mark
** in its beginning plus its first line if it starts with '#'. Returns
** true if it skipped the first line. In any case, '*cp' has the
** first "valid" character of the file (after the optional BOM and
** a first-line comment).
*/
static int luai_skipcomment (luai_LoadF *lf, int *cp) {
int c = *cp = luai_skipBOM(lf);
if (c == '#') { /* first line is a comment (Unix exec. file)? */
do { /* skip first line */
c = getc(lf->f);
} while (c != EOF && c != '\n');
*cp = getc(lf->f); /* skip end-of-line, if present */
return 1; /* there was a comment */
}
else return 0; /* no comment */
}
LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename,
const char *mode) {
luai_LoadF lf;
int status, readstatus;
int c;
int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */
if (filename == NULL) {
lua_pushliteral(L, "=stdin");
lf.f = stdin;
}
else {
lua_pushfstring(L, "@%s", filename);
lf.f = fopen(filename, "r");
if (lf.f == NULL) return luai_errfile(L, "open", fnameindex);
}
if (luai_skipcomment(&lf, &c)) /* read initial portion */
lf.buff[lf.n++] = '\n'; /* add line to correct line numbers */
if (c == LUA_SIGNATURE[0] && filename) { /* binary file? */
lf.f = freopen(filename, "rb", lf.f); /* reopen in binary mode */
if (lf.f == NULL) return luai_errfile(L, "reopen", fnameindex);
luai_skipcomment(&lf, &c); /* re-read initial portion */
}
if (c != EOF)
lf.buff[lf.n++] = c; /* 'c' is the first character of the stream */
status = lua_load(L, luai_getF, &lf, lua_tostring(L, -1), mode);
readstatus = ferror(lf.f);
if (filename) fclose(lf.f); /* close file (even in case of errors) */
if (readstatus) {
lua_settop(L, fnameindex); /* ignore results from 'lua_load' */
return luai_errfile(L, "read", fnameindex);
}
lua_remove(L, fnameindex);
return status;
}
typedef struct luai_LoadS {
const char *s;
size_t size;
} luai_LoadS;
static const char *luai_getS (lua_State *L, void *ud, size_t *size) {
luai_LoadS *ls = (luai_LoadS *)ud;
(void)L; /* not used */
if (ls->size == 0) return NULL;
*size = ls->size;
ls->size = 0;
return ls->s;
}
LUALIB_API int luaL_loadbufferx (lua_State *L, const char *buff, size_t size,
const char *name, const char *mode) {
luai_LoadS ls;
ls.s = buff;
ls.size = size;
return lua_load(L, luai_getS, &ls, name, mode);
}
LUALIB_API int luaL_loadstring (lua_State *L, const char *s) {
return luaL_loadbuffer(L, s, strlen(s), s);
}
/* }====================================================== */
LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
if (!lua_getmetatable(L, obj)) /* no metatable? */
return LUA_TNIL;
else {
int tt;
lua_pushstring(L, event);
tt = lua_rawget(L, -2);
if (tt == LUA_TNIL) /* is metafield nil? */
lua_pop(L, 2); /* remove metatable and metafield */
else
lua_remove(L, -2); /* remove only metatable */
return tt; /* return metafield type */
}
}
LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
obj = lua_absindex(L, obj);
if (luaL_getmetafield(L, obj, event) == LUA_TNIL) /* no metafield? */
return 0;
lua_pushvalue(L, obj);
lua_call(L, 1, 1);
return 1;
}
LUALIB_API lua_Integer luaL_len (lua_State *L, int idx) {
lua_Integer l;
int isnum;
lua_len(L, idx);
l = lua_tointegerx(L, -1, &isnum);
if (!isnum)
luaL_error(L, "object length is not an integer");
lua_pop(L, 1); /* remove object */
return l;
}
LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
if (luaL_callmeta(L, idx, "__tostring")) { /* metafield? */
if (!lua_isstring(L, -1))
luaL_error(L, "'__tostring' must return a string");
}
else {
switch (lua_type(L, idx)) {
case LUA_TNUMBER: {
if (lua_isinteger(L, idx))
lua_pushfstring(L, "%I", (LUAI_UACINT)lua_tointeger(L, idx));
else
lua_pushfstring(L, "%f", (LUAI_UACNUMBER)lua_tonumber(L, idx));
break;
}
case LUA_TSTRING:
lua_pushvalue(L, idx);
break;
case LUA_TBOOLEAN:
lua_pushstring(L, (lua_toboolean(L, idx) ? "true" : "false"));
break;
case LUA_TNIL:
lua_pushliteral(L, "nil");
break;
default: {
int tt = luaL_getmetafield(L, idx, "__name"); /* try name */
const char *kind = (tt == LUA_TSTRING) ? lua_tostring(L, -1) :
luaL_typename(L, idx);
lua_pushfstring(L, "%s: %p", kind, lua_topointer(L, idx));
if (tt != LUA_TNIL)
lua_remove(L, -2); /* remove '__name' */
break;
}
}
}
return lua_tolstring(L, -1, len);
}
/*
** {======================================================
** Compatibility with 5.1 module functions
** =======================================================
*/
#if defined(LUA_COMPAT_MODULE)
static const char *luaL_findtable (lua_State *L, int idx,
const char *fname, int szhint) {
const char *e;
if (idx) lua_pushvalue(L, idx);
do {
e = strchr(fname, '.');
if (e == NULL) e = fname + strlen(fname);
lua_pushlstring(L, fname, e - fname);
if (lua_rawget(L, -2) == LUA_TNIL) { /* no such luai_field? */
lua_pop(L, 1); /* remove this nil */
lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for luai_field */
lua_pushlstring(L, fname, e - fname);
lua_pushvalue(L, -2);
lua_settable(L, -4); /* set new table into luai_field */
}
else if (!lua_istable(L, -1)) { /* luai_field has a non-table value? */
lua_pop(L, 2); /* remove table and value */
return fname; /* return problematic part of the name */
}
lua_remove(L, -2); /* remove previous table */
fname = e + 1;
} while (*e == '.');
return NULL;
}
/*
** Count number of elements in a luaL_Reg list.
*/
static int luai_libsize (const luaL_Reg *l) {
int size = 0;
for (; l && l->name; l++) size++;
return size;
}
/*
** Find or create a module table with a given name. The function
** first looks at the LOADED table and, if that fails, try a
** global variable with that name. In any case, leaves on the stack
** the module table.
*/
LUALIB_API void luaL_pushmodule (lua_State *L, const char *modname,
int sizehint) {
luaL_findtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE, 1);
if (lua_getfield(L, -1, modname) != LUA_TTABLE) { /* no LOADED[modname]? */
lua_pop(L, 1); /* remove previous result */
/* try global variable (and create one if it does not exist) */
lua_pushglobaltable(L);
if (luaL_findtable(L, 0, modname, sizehint) != NULL)
luaL_error(L, "name conflict for module '%s'", modname);
lua_pushvalue(L, -1);
lua_setfield(L, -3, modname); /* LOADED[modname] = new table */
}
lua_remove(L, -2); /* remove LOADED table */
}
LUALIB_API void luaL_openlib (lua_State *L, const char *libname,
const luaL_Reg *l, int nup) {
luaL_checkversion(L);
if (libname) {
luaL_pushmodule(L, libname, luai_libsize(l)); /* get/create library table */
lua_insert(L, -(nup + 1)); /* move library table to below upvalues */
}
if (l)
luaL_setfuncs(L, l, nup);
else
lua_pop(L, nup); /* remove upvalues */
}
#endif
/* }====================================================== */
/*
** set functions from list 'l' into table at top - 'nup'; each
** function gets the 'nup' elements at the top as upvalues.
** Returns with only the table at the stack.
*/
LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
luaL_checkstack(L, nup, "too many upvalues");
for (; l->name != NULL; l++) { /* fill the table with given functions */
int i;
for (i = 0; i < nup; i++) /* copy upvalues to the top */
lua_pushvalue(L, -nup);
lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */
lua_setfield(L, -(nup + 2), l->name);
}
lua_pop(L, nup); /* remove upvalues */
}
/*
** ensure that stack[idx][fname] has a table and push that table
** into the stack
*/
LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
if (lua_getfield(L, idx, fname) == LUA_TTABLE)
return 1; /* table already there */
else {
lua_pop(L, 1); /* remove previous result */
idx = lua_absindex(L, idx);
lua_newtable(L);
lua_pushvalue(L, -1); /* copy to be left at top */
lua_setfield(L, idx, fname); /* assign new table to luai_field */
return 0; /* false, because did not find table there */
}
}
/*
** Stripped-down 'require': After checking "loaded" table, calls 'openf'
** to open a module, registers the result in 'package.loaded' table and,
** if 'glb' is true, also registers the result in the global table.
** Leaves resulting module on the top.
*/
LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
lua_CFunction openf, int glb) {
luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
lua_getfield(L, -1, modname); /* LOADED[modname] */
if (!lua_toboolean(L, -1)) { /* package not already loaded? */
lua_pop(L, 1); /* remove luai_field */
lua_pushcfunction(L, openf);
lua_pushstring(L, modname); /* argument to open function */
lua_call(L, 1, 1); /* call 'openf' to open module */
lua_pushvalue(L, -1); /* make copy of module (call result) */
lua_setfield(L, -3, modname); /* LOADED[modname] = module */
}
lua_remove(L, -2); /* remove LOADED table */
if (glb) {
lua_pushvalue(L, -1); /* copy of module */
lua_setglobal(L, modname); /* _G[modname] = module */
}
}
LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,
const char *r) {
const char *wild;
size_t l = strlen(p);
luaL_Buffer b;
luaL_buffinit(L, &b);
while ((wild = strstr(s, p)) != NULL) {
luaL_addlstring(&b, s, wild - s); /* push prefix */
luaL_addstring(&b, r); /* push replacement in place of pattern */
s = wild + l; /* continue after 'p' */
}
luaL_addstring(&b, s); /* push last suffix */
luaL_pushresult(&b);
return lua_tostring(L, -1);
}
static void *luai_l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
(void)ud; (void)osize; /* not used */
if (nsize == 0) {
free(ptr);
return NULL;
}
else
return realloc(ptr, nsize);
}
static int luai_panic (lua_State *L) {
lua_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n",
lua_tostring(L, -1));
return 0; /* return to Lua to abort */
}
LUALIB_API lua_State *luaL_newstate (void) {
lua_State *L = lua_newstate(luai_l_alloc, NULL);
if (L) lua_atpanic(L, &luai_panic);
return L;
}
LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
const lua_Number *v = lua_version(L);
if (sz != LUAL_NUMSIZES) /* luai_check numeric types */
luaL_error(L, "core and library have incompatible numeric types");
if (v != lua_version(NULL))
luaL_error(L, "multiple Lua VMs detected");
else if (*v != ver)
luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
(LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)*v);
}
/*__lbaselib.c__*/
static int luaB_print (lua_State *L) {
int n = lua_gettop(L); /* number of arguments */
int i;
lua_getglobal(L, "tostring");
for (i=1; i<=n; i++) {
const char *s;
size_t l;
lua_pushvalue(L, -1); /* function to be called */
lua_pushvalue(L, i); /* value to print */
lua_call(L, 1, 1);
s = lua_tolstring(L, -1, &l); /* get result */
if (s == NULL)
return luaL_error(L, "'tostring' must return a string to 'print'");
if (i>1) lua_writestring("\t", 1);
lua_writestring(s, l);
lua_pop(L, 1); /* pop result */
}
lua_writeline();
return 0;
}
#define LUA_SPACECHARS " \f\n\r\t\v"
static const char *luai_b_str2int (const char *s, int base, lua_Integer *pn) {
lua_Unsigned n = 0;
int neg = 0;
s += strspn(s, LUA_SPACECHARS); /* skip initial spaces */
if (*s == '-') { s++; neg = 1; } /* handle signal */
else if (*s == '+') s++;
if (!isalnum((unsigned char)*s)) /* no luai_digit? */
return NULL;
do {
int luai_digit = (isdigit((unsigned char)*s)) ? *s - '0'
: (toupper((unsigned char)*s) - 'A') + 10;
if (luai_digit >= base) return NULL; /* invalid numeral */
n = n * base + luai_digit;
s++;
} while (isalnum((unsigned char)*s));
s += strspn(s, LUA_SPACECHARS); /* skip trailing spaces */
*pn = (lua_Integer)((neg) ? (0u - n) : n);
return s;
}
static int luaB_tonumber (lua_State *L) {
if (lua_isnoneornil(L, 2)) { /* standard conversion? */
luaL_checkany(L, 1);
if (lua_type(L, 1) == LUA_TNUMBER) { /* already a number? */
lua_settop(L, 1); /* yes; return it */
return 1;
}
else {
size_t l;
const char *s = lua_tolstring(L, 1, &l);
if (s != NULL && lua_stringtonumber(L, s) == l + 1)
return 1; /* successful conversion to number */
/* else not a number */
}
}
else {
size_t l;
const char *s;
lua_Integer n = 0; /* to avoid warnings */
lua_Integer base = luaL_checkinteger(L, 2);
luaL_checktype(L, 1, LUA_TSTRING); /* no numbers as strings */
s = lua_tolstring(L, 1, &l);
luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
if (luai_b_str2int(s, (int)base, &n) == s + l) {
lua_pushinteger(L, n);
return 1;
} /* else not a number */
} /* else not a number */
lua_pushnil(L); /* not a number */
return 1;
}
static int luaB_error (lua_State *L) {
int level = (int)luaL_optinteger(L, 2, 1);
lua_settop(L, 1);
if (lua_type(L, 1) == LUA_TSTRING && level > 0) {
luaL_where(L, level); /* add extra information */
lua_pushvalue(L, 1);
lua_concat(L, 2);
}
return lua_error(L);
}
static int luaB_getmetatable (lua_State *L) {
luaL_checkany(L, 1);
if (!lua_getmetatable(L, 1)) {
lua_pushnil(L);
return 1; /* no metatable */
}
luaL_getmetafield(L, 1, "__metatable");
return 1; /* returns either __metatable luai_field (if present) or metatable */
}
static int luaB_setmetatable (lua_State *L) {
int t = lua_type(L, 2);
luaL_checktype(L, 1, LUA_TTABLE);
luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
"nil or table expected");
if (luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL)
return luaL_error(L, "cannot change a protected metatable");
lua_settop(L, 2);
lua_setmetatable(L, 1);
return 1;
}
static int luaB_rawequal (lua_State *L) {
luaL_checkany(L, 1);
luaL_checkany(L, 2);
lua_pushboolean(L, lua_rawequal(L, 1, 2));
return 1;
}
static int luaB_rawlen (lua_State *L) {
int t = lua_type(L, 1);
luaL_argcheck(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,
"table or string expected");
lua_pushinteger(L, lua_rawlen(L, 1));
return 1;
}
static int luaB_rawget (lua_State *L) {
luaL_checktype(L, 1, LUA_TTABLE);
luaL_checkany(L, 2);
lua_settop(L, 2);
lua_rawget(L, 1);
return 1;
}
static int luaB_rawset (lua_State *L) {
luaL_checktype(L, 1, LUA_TTABLE);
luaL_checkany(L, 2);
luaL_checkany(L, 3);
lua_settop(L, 3);
lua_rawset(L, 1);
return 1;
}
static int luaB_collectgarbage (lua_State *L) {
static const char *const opts[] = {"stop", "restart", "collect",
"count", "step", "setpause", "setstepmul",
"isrunning", NULL};
static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
LUA_GCISRUNNING};
int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
int ex = (int)luaL_optinteger(L, 2, 0);
int res = lua_gc(L, o, ex);
switch (o) {
case LUA_GCCOUNT: {
int b = lua_gc(L, LUA_GCCOUNTB, 0);
lua_pushnumber(L, (lua_Number)res + ((lua_Number)b/1024));
return 1;
}
case LUA_GCSTEP: case LUA_GCISRUNNING: {
lua_pushboolean(L, res);
return 1;
}
default: {
lua_pushinteger(L, res);
return 1;
}
}
}
static int luaB_type (lua_State *L) {
int t = lua_type(L, 1);
luaL_argcheck(L, t != LUA_TNONE, 1, "value expected");
lua_pushstring(L, lua_typename(L, t));
return 1;
}
static int luai_pairsmeta (lua_State *L, const char *method, int iszero,
lua_CFunction iter) {
luaL_checkany(L, 1);
if (luaL_getmetafield(L, 1, method) == LUA_TNIL) { /* no metamethod? */
lua_pushcfunction(L, iter); /* will return generator, */
lua_pushvalue(L, 1); /* state, */
if (iszero) lua_pushinteger(L, 0); /* and initial value */
else lua_pushnil(L);
}
else {
lua_pushvalue(L, 1); /* argument 'self' to metamethod */
lua_call(L, 1, 3); /* get 3 values from metamethod */
}
return 3;
}
static int luaB_next (lua_State *L) {
luaL_checktype(L, 1, LUA_TTABLE);
lua_settop(L, 2); /* create a 2nd argument if there isn't one */
if (lua_next(L, 1))
return 2;
else {
lua_pushnil(L);
return 1;
}
}
static int luaB_pairs (lua_State *L) {
return luai_pairsmeta(L, "__pairs", 0, luaB_next);
}
/*
** Traversal function for 'ipairs'
*/
static int luai_ipairsaux (lua_State *L) {
lua_Integer i = luaL_checkinteger(L, 2) + 1;
lua_pushinteger(L, i);
return (lua_geti(L, 1, i) == LUA_TNIL) ? 1 : 2;
}
/*
** 'ipairs' function. Returns 'luai_ipairsaux', given "table", 0.
** (The given "table" may not be a table.)
*/
static int luaB_ipairs (lua_State *L) {
#if defined(LUA_COMPAT_IPAIRS)
return luai_pairsmeta(L, "__ipairs", 1, luai_ipairsaux);
#else
luaL_checkany(L, 1);
lua_pushcfunction(L, luai_ipairsaux); /* iteration function */
lua_pushvalue(L, 1); /* state */
lua_pushinteger(L, 0); /* initial value */
return 3;
#endif
}
static int luai_load_aux (lua_State *L, int status, int envidx) {
if (status == LUA_OK) {
if (envidx != 0) { /* 'env' parameter? */
lua_pushvalue(L, envidx); /* environment for loaded function */
if (!lua_setupvalue(L, -2, 1)) /* set it as 1st upvalue */
lua_pop(L, 1); /* remove 'env' if not used by previous call */
}
return 1;
}
else { /* error (message is on top of the stack) */
lua_pushnil(L);
lua_insert(L, -2); /* put before error message */
return 2; /* return nil plus error message */
}
}
static int luaB_loadfile (lua_State *L) {
const char *fname = luaL_optstring(L, 1, NULL);
const char *mode = luaL_optstring(L, 2, NULL);
int env = (!lua_isnone(L, 3) ? 3 : 0); /* 'env' index or 0 if no 'env' */
int status = luaL_loadfilex(L, fname, mode);
return luai_load_aux(L, status, env);
}
/*
** {======================================================
** Generic Read function
** =======================================================
*/
/*
** reserved slot, above all arguments, to hold a copy of the returned
** string to avoid it being collected while parsed. 'load' has four
** optional arguments (chunk, source name, mode, and environment).
*/
#define LUA_RESERVEDSLOT 5
/*
** Reader for generic 'load' function: 'lua_load' uses the
** stack for internal stuff, so the reader cannot change the
** stack top. Instead, it keeps its resulting string in a
** reserved slot inside the stack.
*/
static const char *luai_generic_reader (lua_State *L, void *ud, size_t *size) {
(void)(ud); /* not used */
luaL_checkstack(L, 2, "too many nested functions");
lua_pushvalue(L, 1); /* get function */
lua_call(L, 0, 1); /* call it */
if (lua_isnil(L, -1)) {
lua_pop(L, 1); /* pop result */
*size = 0;
return NULL;
}
else if (!lua_isstring(L, -1))
luaL_error(L, "reader function must return a string");
lua_replace(L, LUA_RESERVEDSLOT); /* luai_save string in reserved slot */
return lua_tolstring(L, LUA_RESERVEDSLOT, size);
}
static int luaB_load (lua_State *L) {
int status;
size_t l;
const char *s = lua_tolstring(L, 1, &l);
const char *mode = luaL_optstring(L, 3, "bt");
int env = (!lua_isnone(L, 4) ? 4 : 0); /* 'env' index or 0 if no 'env' */
if (s != NULL) { /* loading a string? */
const char *chunkname = luaL_optstring(L, 2, s);
status = luaL_loadbufferx(L, s, l, chunkname, mode);
}
else { /* loading from a reader function */
const char *chunkname = luaL_optstring(L, 2, "=(load)");
luaL_checktype(L, 1, LUA_TFUNCTION);
lua_settop(L, LUA_RESERVEDSLOT); /* create reserved slot */
status = lua_load(L, luai_generic_reader, NULL, chunkname, mode);
}
return luai_load_aux(L, status, env);
}
/* }====================================================== */
static int luai_dofilecont (lua_State *L, int d1, lua_KContext d2) {
(void)d1; (void)d2; /* only to luai_match 'lua_Kfunction' prototype */
return lua_gettop(L) - 1;
}
static int luaB_dofile (lua_State *L) {
const char *fname = luaL_optstring(L, 1, NULL);
lua_settop(L, 1);
if (luaL_loadfile(L, fname) != LUA_OK)
return lua_error(L);
lua_callk(L, 0, LUA_MULTRET, 0, luai_dofilecont);
return luai_dofilecont(L, 0, 0);
}
static int luaB_assert (lua_State *L) {
if (lua_toboolean(L, 1)) /* condition is true? */
return lua_gettop(L); /* return all arguments */
else { /* error */
luaL_checkany(L, 1); /* there must be a condition */
lua_remove(L, 1); /* remove it */
lua_pushliteral(L, "assertion failed!"); /* default message */
lua_settop(L, 1); /* leave only message (default if no other one) */
return luaB_error(L); /* call 'error' */
}
}
static int luaB_select (lua_State *L) {
int n = lua_gettop(L);
if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
lua_pushinteger(L, n-1);
return 1;
}
else {
lua_Integer i = luaL_checkinteger(L, 1);
if (i < 0) i = n + i;
else if (i > n) i = n;
luaL_argcheck(L, 1 <= i, 1, "index out of range");
return n - (int)i;
}
}
/*
** Continuation function for 'pcall' and 'xpcall'. Both functions
** already pushed a 'true' before doing the call, so in case of success
** 'luai_finishpcall' only has to return everything in the stack minus
** 'extra' values (where 'extra' is exactly the number of items to be
** ignored).
*/
static int luai_finishpcall (lua_State *L, int status, lua_KContext extra) {
if (status != LUA_OK && status != LUA_YIELD) { /* error? */
lua_pushboolean(L, 0); /* first result (false) */
lua_pushvalue(L, -2); /* error message */
return 2; /* return false, msg */
}
else
return lua_gettop(L) - (int)extra; /* return all results */
}
static int luaB_pcall (lua_State *L) {
int status;
luaL_checkany(L, 1);
lua_pushboolean(L, 1); /* first result if no errors */
lua_insert(L, 1); /* put it in place */
status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, luai_finishpcall);
return luai_finishpcall(L, status, 0);
}
/*
** Do a protected call with error handling. After 'lua_rotate', the
** stack will have <f, err, true, f, [args...]>; so, the function passes
** 2 to 'luai_finishpcall' to skip the 2 first values when returning results.
*/
static int luaB_xpcall (lua_State *L) {
int status;
int n = lua_gettop(L);
luaL_checktype(L, 2, LUA_TFUNCTION); /* luai_check error function */
lua_pushboolean(L, 1); /* first result */
lua_pushvalue(L, 1); /* function */
lua_rotate(L, 3, 2); /* move them below function's arguments */
status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, luai_finishpcall);
return luai_finishpcall(L, status, 2);
}
static int luaB_tostring (lua_State *L) {
luaL_checkany(L, 1);
luaL_tolstring(L, 1, NULL);
return 1;
}
static const luaL_Reg luai_base_funcs[] = {
{"assert", luaB_assert},
{"collectgarbage", luaB_collectgarbage},
{"dofile", luaB_dofile},
{"error", luaB_error},
{"getmetatable", luaB_getmetatable},
{"ipairs", luaB_ipairs},
{"loadfile", luaB_loadfile},
{"load", luaB_load},
#if defined(LUA_COMPAT_LOADSTRING)
{"loadstring", luaB_load},
#endif
{"next", luaB_next},
{"pairs", luaB_pairs},
{"pcall", luaB_pcall},
{"print", luaB_print},
{"rawequal", luaB_rawequal},
{"rawlen", luaB_rawlen},
{"rawget", luaB_rawget},
{"rawset", luaB_rawset},
{"select", luaB_select},
{"setmetatable", luaB_setmetatable},
{"tonumber", luaB_tonumber},
{"tostring", luaB_tostring},
{"type", luaB_type},
{"xpcall", luaB_xpcall},
/* placeholders */
{"_G", NULL},
{"_VERSION", NULL},
{NULL, NULL}
};
LUAMOD_API int luaopen_base (lua_State *L) {
/* open lib into global table */
lua_pushglobaltable(L);
luaL_setfuncs(L, luai_base_funcs, 0);
/* set global _G */
lua_pushvalue(L, -1);
lua_setfield(L, -2, "_G");
/* set global _VERSION */
lua_pushliteral(L, LUA_VERSION);
lua_setfield(L, -2, "_VERSION");
return 1;
}
/*__lbitlib.c__*/
#if defined(LUA_COMPAT_BITLIB) /* { */
#define luai_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n))
#define luai_checkunsigned(L,i) ((lua_Unsigned)luaL_checkinteger(L,i))
/* number of bits to consider in a number */
#if !defined(LUA_NBITS)
#define LUA_NBITS 32
#endif
/*
** a lua_Unsigned with its first LUA_NBITS bits equal to 1. (Shift must
** be made in two parts to avoid problems when LUA_NBITS is equal to the
** number of bits in a lua_Unsigned.)
*/
#define LUA_ALLONES (~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
/* macro to trim extra bits */
#define lua_trim(x) ((x) & LUA_ALLONES)
/* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */
#define luai_mask(n) (~((LUA_ALLONES << 1) << ((n) - 1)))
static lua_Unsigned lua_andaux (lua_State *L) {
int i, n = lua_gettop(L);
lua_Unsigned r = ~(lua_Unsigned)0;
for (i = 1; i <= n; i++)
r &= luai_checkunsigned(L, i);
return lua_trim(r);
}
static int lua_b_and (lua_State *L) {
lua_Unsigned r = lua_andaux(L);
luai_pushunsigned(L, r);
return 1;
}
static int lua_b_test (lua_State *L) {
lua_Unsigned r = lua_andaux(L);
lua_pushboolean(L, r != 0);
return 1;
}
static int lua_b_or (lua_State *L) {
int i, n = lua_gettop(L);
lua_Unsigned r = 0;
for (i = 1; i <= n; i++)
r |= luai_checkunsigned(L, i);
luai_pushunsigned(L, lua_trim(r));
return 1;
}
static int lua_b_xor (lua_State *L) {
int i, n = lua_gettop(L);
lua_Unsigned r = 0;
for (i = 1; i <= n; i++)
r ^= luai_checkunsigned(L, i);
luai_pushunsigned(L, lua_trim(r));
return 1;
}
static int lua_b_not (lua_State *L) {
lua_Unsigned r = ~luai_checkunsigned(L, 1);
luai_pushunsigned(L, lua_trim(r));
return 1;
}
static int lua_b_shift (lua_State *L, lua_Unsigned r, lua_Integer i) {
if (i < 0) { /* shift right? */
i = -i;
r = lua_trim(r);
if (i >= LUA_NBITS) r = 0;
else r >>= i;
}
else { /* shift left */
if (i >= LUA_NBITS) r = 0;
else r <<= i;
r = lua_trim(r);
}
luai_pushunsigned(L, r);
return 1;
}
static int lua_b_lshift (lua_State *L) {
return lua_b_shift(L, luai_checkunsigned(L, 1), luaL_checkinteger(L, 2));
}
static int lua_b_rshift (lua_State *L) {
return lua_b_shift(L, luai_checkunsigned(L, 1), -luaL_checkinteger(L, 2));
}
static int lua_b_arshift (lua_State *L) {
lua_Unsigned r = luai_checkunsigned(L, 1);
lua_Integer i = luaL_checkinteger(L, 2);
if (i < 0 || !(r & ((lua_Unsigned)1 << (LUA_NBITS - 1))))
return lua_b_shift(L, r, -i);
else { /* arithmetic shift for 'negative' number */
if (i >= LUA_NBITS) r = LUA_ALLONES;
else
r = lua_trim((r >> i) | ~(lua_trim(~(lua_Unsigned)0) >> i)); /* add signal bit */
luai_pushunsigned(L, r);
return 1;
}
}
static int lua_b_rot (lua_State *L, lua_Integer d) {
lua_Unsigned r = luai_checkunsigned(L, 1);
int i = d & (LUA_NBITS - 1); /* i = d % NBITS */
r = lua_trim(r);
if (i != 0) /* avoid undefined shift of LUA_NBITS when i == 0 */
r = (r << i) | (r >> (LUA_NBITS - i));
luai_pushunsigned(L, lua_trim(r));
return 1;
}
static int lua_b_lrot (lua_State *L) {
return lua_b_rot(L, luaL_checkinteger(L, 2));
}
static int lua_b_rrot (lua_State *L) {
return lua_b_rot(L, -luaL_checkinteger(L, 2));
}
/*
** get luai_field and width arguments for luai_field-manipulation functions,
** checking whether they are valid.
** ('luaL_error' called without 'return' to avoid later warnings about
** 'width' being used uninitialized.)
*/
static int lua_fieldargs (lua_State *L, int farg, int *width) {
lua_Integer f = luaL_checkinteger(L, farg);
lua_Integer w = luaL_optinteger(L, farg + 1, 1);
luaL_argcheck(L, 0 <= f, farg, "field cannot be negative");
luaL_argcheck(L, 0 < w, farg + 1, "width must be positive");
if (f + w > LUA_NBITS)
luaL_error(L, "trying to access non-existent bits");
*width = (int)w;
return (int)f;
}
static int lua_b_extract (lua_State *L) {
int w;
lua_Unsigned r = lua_trim(luai_checkunsigned(L, 1));
int f = lua_fieldargs(L, 2, &w);
r = (r >> f) & luai_mask(w);
luai_pushunsigned(L, r);
return 1;
}
static int lua_b_replace (lua_State *L) {
int w;
lua_Unsigned r = lua_trim(luai_checkunsigned(L, 1));
lua_Unsigned v = lua_trim(luai_checkunsigned(L, 2));
int f = lua_fieldargs(L, 3, &w);
lua_Unsigned m = luai_mask(w);
r = (r & ~(m << f)) | ((v & m) << f);
luai_pushunsigned(L, r);
return 1;
}
static const luaL_Reg luai_bitlib[] = {
{"arshift", lua_b_arshift},
{"band", lua_b_and},
{"bnot", lua_b_not},
{"bor", lua_b_or},
{"bxor", lua_b_xor},
{"btest", lua_b_test},
{"extract", lua_b_extract},
{"lrotate", lua_b_lrot},
{"lshift", lua_b_lshift},
{"replace", lua_b_replace},
{"rrotate", lua_b_rrot},
{"rshift", lua_b_rshift},
{NULL, NULL}
};
LUAMOD_API int luaopen_bit32 (lua_State *L) {
luaL_newlib(L, luai_bitlib);
return 1;
}
#else /* }{ */
LUAMOD_API int luaopen_bit32 (lua_State *L) {
return luaL_error(L, "library 'bit32' has been deprecated");
}
#endif /* } */
/*__lcode.c__*/
/* Maximum number of registers in a Lua function (must fit in 8 bits) */
#define LUA_MAXREGS 255
#define lua_hasjumps(e) ((e)->t != (e)->f)
/*
** If expression is a numeric constant, fills 'v' with its value
** and returns 1. Otherwise, returns 0.
*/
static int lua_tonumeral(const luai_expdesc *e, luai_TValue *v) {
if (lua_hasjumps(e))
return 0; /* not a numeral */
switch (e->k) {
case LUAI_VKINT:
if (v) luai_setivalue(v, e->u.ival);
return 1;
case LUAI_VKFLT:
if (v) luai_setfltvalue(v, e->u.nval);
return 1;
default: return 0;
}
}
/*
** Create a luai_OP_LOADNIL instruction, but try to optimize: if the previous
** instruction is also luai_OP_LOADNIL and ranges are compatible, adjust
** range of previous instruction instead of emitting a new one. (For
** instance, 'local a; local b' will generate a single opcode.)
*/
void luaK_nil (luai_FuncState *fs, int from, int n) {
Instruction *previous;
int l = from + n - 1; /* last register to set nil */
if (fs->pc > fs->lasttarget) { /* no jumps to current position? */
previous = &fs->f->code[fs->pc-1];
if (luai_GETOPCODE(*previous) == luai_OP_LOADNIL) { /* previous is LOADNIL? */
int pfrom = luai_GETARG_A(*previous); /* get previous range */
int pl = pfrom + luai_GETARG_B(*previous);
if ((pfrom <= from && from <= pl + 1) ||
(from <= pfrom && pfrom <= l + 1)) { /* can connect both? */
if (pfrom < from) from = pfrom; /* from = min(from, pfrom) */
if (pl > l) l = pl; /* l = max(l, pl) */
luai_SETARG_A(*previous, from);
luai_SETARG_B(*previous, l - from);
return;
}
} /* else go through */
}
luaK_codeABC(fs, luai_OP_LOADNIL, from, n - 1, 0); /* else no optimization */
}
/*
** Gets the destination address of a jump instruction. Used to traverse
** a list of jumps.
*/
static int luai_getjump (luai_FuncState *fs, int pc) {
int offset = luai_GETARG_sBx(fs->f->code[pc]);
if (offset == LUAI_NO_JUMP) /* point to itself represents end of list */
return LUAI_NO_JUMP; /* end of list */
else
return (pc+1)+offset; /* turn offset into absolute position */
}
/*
** Fix jump instruction at position 'pc' to jump to 'dest'.
** (Jump addresses are relative in Lua)
*/
static void luai_fixjump (luai_FuncState *fs, int pc, int dest) {
Instruction *jmp = &fs->f->code[pc];
int offset = dest - (pc + 1);
lua_assert(dest != LUAI_NO_JUMP);
if (abs(offset) > luai_MAXARG_sBx)
luaX_syntaxerror(fs->ls, "control structure too long");
luai_SETARG_sBx(*jmp, offset);
}
/*
** Concatenate jump-list 'l2' into jump-list 'l1'
*/
void luaK_concat (luai_FuncState *fs, int *l1, int l2) {
if (l2 == LUAI_NO_JUMP) return; /* nothing to concatenate? */
else if (*l1 == LUAI_NO_JUMP) /* no original list? */
*l1 = l2; /* 'l1' points to 'l2' */
else {
int list = *l1;
int luai_next;
while ((luai_next = luai_getjump(fs, list)) != LUAI_NO_JUMP) /* find last element */
list = luai_next;
luai_fixjump(fs, list, l2); /* last element links to 'l2' */
}
}
/*
** Create a jump instruction and return its position, so its destination
** can be fixed later (with 'luai_fixjump'). If there are jumps to
** this position (kept in 'jpc'), link them all together so that
** 'luai_patchlistaux' will fix all them directly to the final destination.
*/
int luaK_jump (luai_FuncState *fs) {
int jpc = fs->jpc; /* luai_save list of jumps to here */
int j;
fs->jpc = LUAI_NO_JUMP; /* no more jumps to here */
j = luaK_codeAsBx(fs, luai_OP_JMP, 0, LUAI_NO_JUMP);
luaK_concat(fs, &j, jpc); /* keep them on hold */
return j;
}
/*
** Code a 'return' instruction
*/
void luaK_ret (luai_FuncState *fs, int first, int nret) {
luaK_codeABC(fs, luai_OP_RETURN, first, nret+1, 0);
}
/*
** Code a "conditional jump", that is, a test or comparison opcode
** followed by a jump. Return jump position.
*/
static int luai_condjump (luai_FuncState *fs, luai_OpCode op, int A, int B, int C) {
luaK_codeABC(fs, op, A, B, C);
return luaK_jump(fs);
}
/*
** returns current 'pc' and marks it as a jump target (to avoid wrong
** optimizations with consecutive instructions not in the same basic luai_getblock).
*/
int luaK_getlabel (luai_FuncState *fs) {
fs->lasttarget = fs->pc;
return fs->pc;
}
/*
** Returns the position of the instruction "controlling" a given
** jump (that is, its condition), or the jump itself if it is
** unconditional.
*/
static Instruction *luai_getjumpcontrol (luai_FuncState *fs, int pc) {
Instruction *pi = &fs->f->code[pc];
if (pc >= 1 && luai_testTMode(luai_GETOPCODE(*(pi-1))))
return pi-1;
else
return pi;
}
/*
** Patch destination register for a TESTSET instruction.
** If instruction in position 'node' is not a TESTSET, return 0 ("fails").
** Otherwise, if 'reg' is not 'luai_NO_REG', set it as the destination
** register. Otherwise, change instruction to a simple 'TEST' (produces
** no register value)
*/
static int luai_patchtestreg (luai_FuncState *fs, int node, int reg) {
Instruction *i = luai_getjumpcontrol(fs, node);
if (luai_GETOPCODE(*i) != luai_OP_TESTSET)
return 0; /* cannot patch other instructions */
if (reg != luai_NO_REG && reg != luai_GETARG_B(*i))
luai_SETARG_A(*i, reg);
else {
/* no register to put value or register already has the value;
change instruction to simple test */
*i = luai_CREATE_ABC(luai_OP_TEST, luai_GETARG_B(*i), 0, luai_GETARG_C(*i));
}
return 1;
}
/*
** Traverse a list of tests ensuring no one produces a value
*/
static void luai_removevalues (luai_FuncState *fs, int list) {
for (; list != LUAI_NO_JUMP; list = luai_getjump(fs, list))
luai_patchtestreg(fs, list, luai_NO_REG);
}
/*
** Traverse a list of tests, patching their destination address and
** registers: tests producing values jump to 'vtarget' (and put their
** values in 'reg'), other tests jump to 'dtarget'.
*/
static void luai_patchlistaux (luai_FuncState *fs, int list, int vtarget, int reg,
int dtarget) {
while (list != LUAI_NO_JUMP) {
int luai_next = luai_getjump(fs, list);
if (luai_patchtestreg(fs, list, reg))
luai_fixjump(fs, list, vtarget);
else
luai_fixjump(fs, list, dtarget); /* jump to default target */
list = luai_next;
}
}
/*
** Ensure all pending jumps to current position are fixed (jumping
** to current position with no values) and reset list of pending
** jumps
*/
static void luai_dischargejpc (luai_FuncState *fs) {
luai_patchlistaux(fs, fs->jpc, fs->pc, luai_NO_REG, fs->pc);
fs->jpc = LUAI_NO_JUMP;
}
/*
** Add elements in 'list' to list of pending jumps to "here"
** (current position)
*/
void luaK_patchtohere (luai_FuncState *fs, int list) {
luaK_getlabel(fs); /* mark "here" as a jump target */
luaK_concat(fs, &fs->jpc, list);
}
/*
** Path all jumps in 'list' to jump to 'target'.
** (The assert means that we cannot fix a jump to a forward address
** because we only know addresses once code is generated.)
*/
void luaK_patchlist (luai_FuncState *fs, int list, int target) {
if (target == fs->pc) /* 'target' is current position? */
luaK_patchtohere(fs, list); /* add list to pending jumps */
else {
lua_assert(target < fs->pc);
luai_patchlistaux(fs, list, target, luai_NO_REG, target);
}
}
/*
** Path all jumps in 'list' to close upvalues up to given 'level'
** (The assertion checks that jumps either were closing nothing
** or were closing higher levels, from inner blocks.)
*/
void luaK_patchclose (luai_FuncState *fs, int list, int level) {
level++; /* argument is +1 to reserve 0 as non-op */
for (; list != LUAI_NO_JUMP; list = luai_getjump(fs, list)) {
lua_assert(luai_GETOPCODE(fs->f->code[list]) == luai_OP_JMP &&
(luai_GETARG_A(fs->f->code[list]) == 0 ||
luai_GETARG_A(fs->f->code[list]) >= level));
luai_SETARG_A(fs->f->code[list], level);
}
}
/*
** Emit instruction 'i', checking for array sizes and saving also its
** line information. Return 'i' position.
*/
static int luaK_code (luai_FuncState *fs, Instruction i) {
luai_Proto *f = fs->f;
luai_dischargejpc(fs); /* 'pc' will change */
/* put new instruction in code array */
luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction,
LUAI_MAX_INT, "opcodes");
f->code[fs->pc] = i;
/* luai_save corresponding line information */
luaM_growvector(fs->ls->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
LUAI_MAX_INT, "opcodes");
f->lineinfo[fs->pc] = fs->ls->lastline;
return fs->pc++;
}
/*
** Format and emit an 'luai_iABC' instruction. (Assertions luai_check consistency
** of parameters versus opcode.)
*/
int luaK_codeABC (luai_FuncState *fs, luai_OpCode o, int a, int b, int c) {
lua_assert(luai_getOpMode(o) == luai_iABC);
lua_assert(luai_getBMode(o) != luai_OpArgN || b == 0);
lua_assert(luai_getCMode(o) != luai_OpArgN || c == 0);
lua_assert(a <= luai_MAXARG_A && b <= luai_MAXARG_B && c <= luai_MAXARG_C);
return luaK_code(fs, luai_CREATE_ABC(o, a, b, c));
}
/*
** Format and emit an 'luai_iABx' instruction.
*/
int luaK_codeABx (luai_FuncState *fs, luai_OpCode o, int a, unsigned int bc) {
lua_assert(luai_getOpMode(o) == luai_iABx || luai_getOpMode(o) == luai_iAsBx);
lua_assert(luai_getCMode(o) == luai_OpArgN);
lua_assert(a <= luai_MAXARG_A && bc <= luai_MAXARG_Bx);
return luaK_code(fs, luai_CREATE_ABx(o, a, bc));
}
/*
** Emit an "extra argument" instruction (format 'luai_iAx')
*/
static int luai_codeextraarg (luai_FuncState *fs, int a) {
lua_assert(a <= luai_MAXARG_Ax);
return luaK_code(fs, luai_CREATE_Ax(luai_OP_EXTRAARG, a));
}
/*
** Emit a "load constant" instruction, using either 'luai_OP_LOADK'
** (if constant index 'k' fits in 18 bits) or an 'luai_OP_LOADKX'
** instruction with "extra argument".
*/
int luaK_codek (luai_FuncState *fs, int reg, int k) {
if (k <= luai_MAXARG_Bx)
return luaK_codeABx(fs, luai_OP_LOADK, reg, k);
else {
int p = luaK_codeABx(fs, luai_OP_LOADKX, reg, 0);
luai_codeextraarg(fs, k);
return p;
}
}
/*
** Check register-stack level, keeping track of its maximum size
** in luai_field 'maxstacksize'
*/
void luaK_checkstack (luai_FuncState *fs, int n) {
int newstack = fs->luai_freereg + n;
if (newstack > fs->f->maxstacksize) {
if (newstack >= LUA_MAXREGS)
luaX_syntaxerror(fs->ls,
"function or expression needs too many registers");
fs->f->maxstacksize = luai_cast_byte(newstack);
}
}
/*
** Reserve 'n' registers in register stack
*/
void luaK_reserveregs (luai_FuncState *fs, int n) {
luaK_checkstack(fs, n);
fs->luai_freereg += n;
}
/*
** Free register 'reg', if it is neither a constant index nor
** a local variable.
)
*/
static void luai_freereg (luai_FuncState *fs, int reg) {
if (!luai_ISK(reg) && reg >= fs->nactvar) {
fs->luai_freereg--;
lua_assert(reg == fs->luai_freereg);
}
}
/*
** Free register used by expression 'e' (if any)
*/
static void luai_freeexp (luai_FuncState *fs, luai_expdesc *e) {
if (e->k == LUAI_VNONRELOC)
luai_freereg(fs, e->u.info);
}
/*
** Free registers used by expressions 'e1' and 'e2' (if any) in proper
** order.
*/
static void luai_freeexps (luai_FuncState *fs, luai_expdesc *e1, luai_expdesc *e2) {
int r1 = (e1->k == LUAI_VNONRELOC) ? e1->u.info : -1;
int r2 = (e2->k == LUAI_VNONRELOC) ? e2->u.info : -1;
if (r1 > r2) {
luai_freereg(fs, r1);
luai_freereg(fs, r2);
}
else {
luai_freereg(fs, r2);
luai_freereg(fs, r1);
}
}
/*
** Add constant 'v' to prototype's list of constants (luai_field 'k').
** Use scanner's table to cache position of constants in constant list
** and try to reuse constants. Because some values should not be used
** as keys (nil cannot be a key, integer keys can collapse with float
** keys), the caller must provide a useful 'key' for indexing the cache.
*/
static int luai_addk (luai_FuncState *fs, luai_TValue *key, luai_TValue *v) {
lua_State *L = fs->ls->L;
luai_Proto *f = fs->f;
luai_TValue *idx = luaH_set(L, fs->ls->h, key); /* index scanner table */
int k, oldsize;
if (luai_ttisinteger(idx)) { /* is there an index there? */
k = luai_cast_int(luai_ivalue(idx));
/* correct value? (warning: must distinguish floats from integers!) */
if (k < fs->nk && luai_ttype(&f->k[k]) == luai_ttype(v) &&
luaV_rawequalobj(&f->k[k], v))
return k; /* reuse index */
}
/* constant not found; create a new entry */
oldsize = f->sizek;
k = fs->nk;
/* numerical value does not need LUAI_GC barrier;
table has no metatable, so it does not need to invalidate cache */
luai_setivalue(idx, k);
luaM_growvector(L, f->k, k, f->sizek, luai_TValue, luai_MAXARG_Ax, "constants");
while (oldsize < f->sizek) luai_setnilvalue(&f->k[oldsize++]);
luai_setobj(L, &f->k[k], v);
fs->nk++;
luaC_barrier(L, f, v);
return k;
}
/*
** Add a string to list of constants and return its index.
*/
int luaK_stringK (luai_FuncState *fs, luai_TString *s) {
luai_TValue o;
luai_setsvalue(fs->ls->L, &o, s);
return luai_addk(fs, &o, &o); /* use string itself as key */
}
/*
** Add an integer to list of constants and return its index.
** Integers use userdata as keys to avoid collision with floats with
** same value; conversion to 'void*' is used only for hashing, so there
** are no "precision" problems.
*/
int luaK_intK (luai_FuncState *fs, lua_Integer n) {
luai_TValue k, o;
luai_setpvalue(&k, luai_cast(void*, luai_cast(size_t, n)));
luai_setivalue(&o, n);
return luai_addk(fs, &k, &o);
}
/*
** Add a float to list of constants and return its index.
*/
static int luaK_numberK (luai_FuncState *fs, lua_Number r) {
luai_TValue o;
luai_setfltvalue(&o, r);
return luai_addk(fs, &o, &o); /* use number itself as key */
}
/*
** Add a boolean to list of constants and return its index.
*/
static int luai_boolK (luai_FuncState *fs, int b) {
luai_TValue o;
luai_setbvalue(&o, b);
return luai_addk(fs, &o, &o); /* use boolean itself as key */
}
/*
** Add nil to list of constants and return its index.
*/
static int luai_nilK (luai_FuncState *fs) {
luai_TValue k, v;
luai_setnilvalue(&v);
/* cannot use nil as key; instead use table itself to represent nil */
luai_sethvalue(fs->ls->L, &k, fs->ls->h);
return luai_addk(fs, &k, &v);
}
/*
** Fix an expression to return the number of results 'nresults'.
** Either 'e' is a multi-ret expression (function call or vararg)
** or 'nresults' is LUA_MULTRET (as any expression can satisfy that).
*/
void luaK_setreturns (luai_FuncState *fs, luai_expdesc *e, int nresults) {
if (e->k == LUAI_VCALL) { /* expression is an open function call? */
luai_SETARG_C(luai_getinstruction(fs, e), nresults + 1);
}
else if (e->k == LUAI_VVARARG) {
Instruction *pc = &luai_getinstruction(fs, e);
luai_SETARG_B(*pc, nresults + 1);
luai_SETARG_A(*pc, fs->luai_freereg);
luaK_reserveregs(fs, 1);
}
else lua_assert(nresults == LUA_MULTRET);
}
/*
** Fix an expression to return one result.
** If expression is not a multi-ret expression (function call or
** vararg), it already returns one result, so nothing needs to be done.
** Function calls become LUAI_VNONRELOC expressions (as its result comes
** fixed in the base register of the call), while vararg expressions
** become LUAI_VRELOCABLE (as luai_OP_VARARG puts its results where it wants).
** (Calls are created returning one result, so that does not need
** to be fixed.)
*/
void luaK_setoneret (luai_FuncState *fs, luai_expdesc *e) {
if (e->k == LUAI_VCALL) { /* expression is an open function call? */
/* already returns 1 value */
lua_assert(luai_GETARG_C(luai_getinstruction(fs, e)) == 2);
e->k = LUAI_VNONRELOC; /* result has fixed position */
e->u.info = luai_GETARG_A(luai_getinstruction(fs, e));
}
else if (e->k == LUAI_VVARARG) {
luai_SETARG_B(luai_getinstruction(fs, e), 2);
e->k = LUAI_VRELOCABLE; /* can relocate its simple result */
}
}
/*
** Ensure that expression 'e' is not a variable.
*/
void luaK_dischargevars (luai_FuncState *fs, luai_expdesc *e) {
switch (e->k) {
case LUAI_VLOCAL: { /* already in a register */
e->k = LUAI_VNONRELOC; /* becomes a non-relocatable value */
break;
}
case LUAI_VUPVAL: { /* move value to some (pending) register */
e->u.info = luaK_codeABC(fs, luai_OP_GETUPVAL, 0, e->u.info, 0);
e->k = LUAI_VRELOCABLE;
break;
}
case LUAI_VINDEXED: {
luai_OpCode op;
luai_freereg(fs, e->u.ind.idx);
if (e->u.ind.vt == LUAI_VLOCAL) { /* is 't' in a register? */
luai_freereg(fs, e->u.ind.t);
op = luai_OP_GETTABLE;
}
else {
lua_assert(e->u.ind.vt == LUAI_VUPVAL);
op = luai_OP_GETTABUP; /* 't' is in an upvalue */
}
e->u.info = luaK_codeABC(fs, op, 0, e->u.ind.t, e->u.ind.idx);
e->k = LUAI_VRELOCABLE;
break;
}
case LUAI_VVARARG: case LUAI_VCALL: {
luaK_setoneret(fs, e);
break;
}
default: break; /* there is one value available (somewhere) */
}
}
/*
** Ensures expression value is in register 'reg' (and therefore
** 'e' will become a non-relocatable expression).
*/
static void luai_discharge2reg (luai_FuncState *fs, luai_expdesc *e, int reg) {
luaK_dischargevars(fs, e);
switch (e->k) {
case LUAI_VNIL: {
luaK_nil(fs, reg, 1);
break;
}
case LUAI_VFALSE: case LUAI_VTRUE: {
luaK_codeABC(fs, luai_OP_LOADBOOL, reg, e->k == LUAI_VTRUE, 0);
break;
}
case LUAI_VK: {
luaK_codek(fs, reg, e->u.info);
break;
}
case LUAI_VKFLT: {
luaK_codek(fs, reg, luaK_numberK(fs, e->u.nval));
break;
}
case LUAI_VKINT: {
luaK_codek(fs, reg, luaK_intK(fs, e->u.ival));
break;
}
case LUAI_VRELOCABLE: {
Instruction *pc = &luai_getinstruction(fs, e);
luai_SETARG_A(*pc, reg); /* instruction will put result in 'reg' */
break;
}
case LUAI_VNONRELOC: {
if (reg != e->u.info)
luaK_codeABC(fs, luai_OP_MOVE, reg, e->u.info, 0);
break;
}
default: {
lua_assert(e->k == LUAI_VJMP);
return; /* nothing to do... */
}
}
e->u.info = reg;
e->k = LUAI_VNONRELOC;
}
/*
** Ensures expression value is in any register.
*/
static void luai_discharge2anyreg (luai_FuncState *fs, luai_expdesc *e) {
if (e->k != LUAI_VNONRELOC) { /* no fixed register yet? */
luaK_reserveregs(fs, 1); /* get a register */
luai_discharge2reg(fs, e, fs->luai_freereg-1); /* put value there */
}
}
static int luai_code_loadbool (luai_FuncState *fs, int A, int b, int jump) {
luaK_getlabel(fs); /* those instructions may be jump targets */
return luaK_codeABC(fs, luai_OP_LOADBOOL, A, b, jump);
}
/*
** luai_check whether list has any jump that do not produce a value
** or produce an inverted value
*/
static int luai_need_value (luai_FuncState *fs, int list) {
for (; list != LUAI_NO_JUMP; list = luai_getjump(fs, list)) {
Instruction i = *luai_getjumpcontrol(fs, list);
if (luai_GETOPCODE(i) != luai_OP_TESTSET) return 1;
}
return 0; /* not found */
}
/*
** Ensures final expression result (including results from its jump
** lists) is in register 'reg'.
** If expression has jumps, need to patch these jumps either to
** its final position or to "load" instructions (for those tests
** that do not produce values).
*/
static void luai_exp2reg (luai_FuncState *fs, luai_expdesc *e, int reg) {
luai_discharge2reg(fs, e, reg);
if (e->k == LUAI_VJMP) /* expression itself is a test? */
luaK_concat(fs, &e->t, e->u.info); /* put this jump in 't' list */
if (lua_hasjumps(e)) {
int final; /* position after whole expression */
int p_f = LUAI_NO_JUMP; /* position of an eventual LOAD false */
int p_t = LUAI_NO_JUMP; /* position of an eventual LOAD true */
if (luai_need_value(fs, e->t) || luai_need_value(fs, e->f)) {
int fj = (e->k == LUAI_VJMP) ? LUAI_NO_JUMP : luaK_jump(fs);
p_f = luai_code_loadbool(fs, reg, 0, 1);
p_t = luai_code_loadbool(fs, reg, 1, 0);
luaK_patchtohere(fs, fj);
}
final = luaK_getlabel(fs);
luai_patchlistaux(fs, e->f, final, reg, p_f);
luai_patchlistaux(fs, e->t, final, reg, p_t);
}
e->f = e->t = LUAI_NO_JUMP;
e->u.info = reg;
e->k = LUAI_VNONRELOC;
}
/*
** Ensures final expression result (including results from its jump
** lists) is in luai_next available register.
*/
void luaK_exp2nextreg (luai_FuncState *fs, luai_expdesc *e) {
luaK_dischargevars(fs, e);
luai_freeexp(fs, e);
luaK_reserveregs(fs, 1);
luai_exp2reg(fs, e, fs->luai_freereg - 1);
}
/*
** Ensures final expression result (including results from its jump
** lists) is in some (any) register and return that register.
*/
int luaK_exp2anyreg (luai_FuncState *fs, luai_expdesc *e) {
luaK_dischargevars(fs, e);
if (e->k == LUAI_VNONRELOC) { /* expression already has a register? */
if (!lua_hasjumps(e)) /* no jumps? */
return e->u.info; /* result is already in a register */
if (e->u.info >= fs->nactvar) { /* reg. is not a local? */
luai_exp2reg(fs, e, e->u.info); /* put final result in it */
return e->u.info;
}
}
luaK_exp2nextreg(fs, e); /* otherwise, use luai_next available register */
return e->u.info;
}
/*
** Ensures final expression result is either in a register or in an
** upvalue.
*/
void luaK_exp2anyregup (luai_FuncState *fs, luai_expdesc *e) {
if (e->k != LUAI_VUPVAL || lua_hasjumps(e))
luaK_exp2anyreg(fs, e);
}
/*
** Ensures final expression result is either in a register or it is
** a constant.
*/
void luaK_exp2val (luai_FuncState *fs, luai_expdesc *e) {
if (lua_hasjumps(e))
luaK_exp2anyreg(fs, e);
else
luaK_dischargevars(fs, e);
}
/*
** Ensures final expression result is in a valid R/K index
** (that is, it is either in a register or in 'k' with an index
** in the range of R/K indices).
** Returns R/K index.
*/
int luaK_exp2RK (luai_FuncState *fs, luai_expdesc *e) {
luaK_exp2val(fs, e);
switch (e->k) { /* move constants to 'k' */
case LUAI_VTRUE: e->u.info = luai_boolK(fs, 1); goto vk;
case LUAI_VFALSE: e->u.info = luai_boolK(fs, 0); goto vk;
case LUAI_VNIL: e->u.info = luai_nilK(fs); goto vk;
case LUAI_VKINT: e->u.info = luaK_intK(fs, e->u.ival); goto vk;
case LUAI_VKFLT: e->u.info = luaK_numberK(fs, e->u.nval); goto vk;
case LUAI_VK:
vk:
e->k = LUAI_VK;
if (e->u.info <= luai_MAXINDEXRK) /* constant fits in 'argC'? */
return luai_RKASK(e->u.info);
else break;
default: break;
}
/* not a constant in the right range: put it in a register */
return luaK_exp2anyreg(fs, e);
}
/*
** Generate code to store result of expression 'ex' into variable 'var'.
*/
void luaK_storevar (luai_FuncState *fs, luai_expdesc *var, luai_expdesc *ex) {
switch (var->k) {
case LUAI_VLOCAL: {
luai_freeexp(fs, ex);
luai_exp2reg(fs, ex, var->u.info); /* compute 'ex' into proper place */
return;
}
case LUAI_VUPVAL: {
int e = luaK_exp2anyreg(fs, ex);
luaK_codeABC(fs, luai_OP_SETUPVAL, e, var->u.info, 0);
break;
}
case LUAI_VINDEXED: {
luai_OpCode op = (var->u.ind.vt == LUAI_VLOCAL) ? luai_OP_SETTABLE : luai_OP_SETTABUP;
int e = luaK_exp2RK(fs, ex);
luaK_codeABC(fs, op, var->u.ind.t, var->u.ind.idx, e);
break;
}
default: lua_assert(0); /* invalid var kind to store */
}
luai_freeexp(fs, ex);
}
/*
** Emit SELF instruction (convert expression 'e' into 'e:key(e,').
*/
void luaK_self (luai_FuncState *fs, luai_expdesc *e, luai_expdesc *key) {
int ereg;
luaK_exp2anyreg(fs, e);
ereg = e->u.info; /* register where 'e' was placed */
luai_freeexp(fs, e);
e->u.info = fs->luai_freereg; /* base register for op_self */
e->k = LUAI_VNONRELOC; /* self expression has a fixed register */
luaK_reserveregs(fs, 2); /* function and 'self' produced by op_self */
luaK_codeABC(fs, luai_OP_SELF, e->u.info, ereg, luaK_exp2RK(fs, key));
luai_freeexp(fs, key);
}
/*
** Negate condition 'e' (where 'e' is a comparison).
*/
static void luai_negatecondition (luai_FuncState *fs, luai_expdesc *e) {
Instruction *pc = luai_getjumpcontrol(fs, e->u.info);
lua_assert(luai_testTMode(luai_GETOPCODE(*pc)) && luai_GETOPCODE(*pc) != luai_OP_TESTSET &&
luai_GETOPCODE(*pc) != luai_OP_TEST);
luai_SETARG_A(*pc, !(luai_GETARG_A(*pc)));
}
/*
** Emit instruction to jump if 'e' is 'luai_cond' (that is, if 'luai_cond'
** is true, code will jump if 'e' is true.) Return jump position.
** Optimize when 'e' is 'not' something, inverting the condition
** and removing the 'not'.
*/
static int luai_jumponcond (luai_FuncState *fs, luai_expdesc *e, int luai_cond) {
if (e->k == LUAI_VRELOCABLE) {
Instruction ie = luai_getinstruction(fs, e);
if (luai_GETOPCODE(ie) == luai_OP_NOT) {
fs->pc--; /* remove previous luai_OP_NOT */
return luai_condjump(fs, luai_OP_TEST, luai_GETARG_B(ie), 0, !luai_cond);
}
/* else go through */
}
luai_discharge2anyreg(fs, e);
luai_freeexp(fs, e);
return luai_condjump(fs, luai_OP_TESTSET, luai_NO_REG, e->u.info, luai_cond);
}
/*
** Emit code to go through if 'e' is true, jump otherwise.
*/
void luaK_goiftrue (luai_FuncState *fs, luai_expdesc *e) {
int pc; /* pc of new jump */
luaK_dischargevars(fs, e);
switch (e->k) {
case LUAI_VJMP: { /* condition? */
luai_negatecondition(fs, e); /* jump when it is false */
pc = e->u.info; /* luai_save jump position */
break;
}
case LUAI_VK: case LUAI_VKFLT: case LUAI_VKINT: case LUAI_VTRUE: {
pc = LUAI_NO_JUMP; /* always true; do nothing */
break;
}
default: {
pc = luai_jumponcond(fs, e, 0); /* jump when false */
break;
}
}
luaK_concat(fs, &e->f, pc); /* insert new jump in false list */
luaK_patchtohere(fs, e->t); /* true list jumps to here (to go through) */
e->t = LUAI_NO_JUMP;
}
/*
** Emit code to go through if 'e' is false, jump otherwise.
*/
void luaK_goiffalse (luai_FuncState *fs, luai_expdesc *e) {
int pc; /* pc of new jump */
luaK_dischargevars(fs, e);
switch (e->k) {
case LUAI_VJMP: {
pc = e->u.info; /* already jump if true */
break;
}
case LUAI_VNIL: case LUAI_VFALSE: {
pc = LUAI_NO_JUMP; /* always false; do nothing */
break;
}
default: {
pc = luai_jumponcond(fs, e, 1); /* jump if true */
break;
}
}
luaK_concat(fs, &e->t, pc); /* insert new jump in 't' list */
luaK_patchtohere(fs, e->f); /* false list jumps to here (to go through) */
e->f = LUAI_NO_JUMP;
}
/*
** Code 'not e', doing constant folding.
*/
static void luai_codenot (luai_FuncState *fs, luai_expdesc *e) {
luaK_dischargevars(fs, e);
switch (e->k) {
case LUAI_VNIL: case LUAI_VFALSE: {
e->k = LUAI_VTRUE; /* true == not nil == not false */
break;
}
case LUAI_VK: case LUAI_VKFLT: case LUAI_VKINT: case LUAI_VTRUE: {
e->k = LUAI_VFALSE; /* false == not "x" == not 0.5 == not 1 == not true */
break;
}
case LUAI_VJMP: {
luai_negatecondition(fs, e);
break;
}
case LUAI_VRELOCABLE:
case LUAI_VNONRELOC: {
luai_discharge2anyreg(fs, e);
luai_freeexp(fs, e);
e->u.info = luaK_codeABC(fs, luai_OP_NOT, 0, e->u.info, 0);
e->k = LUAI_VRELOCABLE;
break;
}
default: lua_assert(0); /* cannot happen */
}
/* interchange true and false lists */
{ int temp = e->f; e->f = e->t; e->t = temp; }
luai_removevalues(fs, e->f); /* values are useless when negated */
luai_removevalues(fs, e->t);
}
/*
** Create expression 't[k]'. 't' must have its final result already in a
** register or upvalue.
*/
void luaK_indexed (luai_FuncState *fs, luai_expdesc *t, luai_expdesc *k) {
lua_assert(!lua_hasjumps(t) && (luai_vkisinreg(t->k) || t->k == LUAI_VUPVAL));
t->u.ind.t = t->u.info; /* register or upvalue index */
t->u.ind.idx = luaK_exp2RK(fs, k); /* R/K index for key */
t->u.ind.vt = (t->k == LUAI_VUPVAL) ? LUAI_VUPVAL : LUAI_VLOCAL;
t->k = LUAI_VINDEXED;
}
/*
** Return false if folding can raise an error.
** Bitwise operations need operands convertible to integers; division
** operations cannot have 0 as divisor.
*/
static int luai_validop (int op, luai_TValue *v1, luai_TValue *v2) {
switch (op) {
case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */
lua_Integer i;
return (luai_tointeger(v1, &i) && luai_tointeger(v2, &i));
}
case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */
return (luai_nvalue(v2) != 0);
default: return 1; /* everything else is valid */
}
}
/*
** Try to "constant-fold" an operation; return 1 iff successful.
** (In this case, 'e1' has the final result.)
*/
static int luai_constfolding (luai_FuncState *fs, int op, luai_expdesc *e1,
const luai_expdesc *e2) {
luai_TValue v1, v2, res;
if (!lua_tonumeral(e1, &v1) || !lua_tonumeral(e2, &v2) || !luai_validop(op, &v1, &v2))
return 0; /* non-numeric operands or not safe to fold */
luaO_arith(fs->ls->L, op, &v1, &v2, &res); /* does operation */
if (luai_ttisinteger(&res)) {
e1->k = LUAI_VKINT;
e1->u.ival = luai_ivalue(&res);
}
else { /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */
lua_Number n = luai_fltvalue(&res);
if (luai_numisnan(n) || n == 0)
return 0;
e1->k = LUAI_VKFLT;
e1->u.nval = n;
}
return 1;
}
/*
** Emit code for unary expressions that "produce values"
** (everything but 'not').
** Expression to produce final result will be encoded in 'e'.
*/
static void luai_codeunexpval (luai_FuncState *fs, luai_OpCode op, luai_expdesc *e, int line) {
int r = luaK_exp2anyreg(fs, e); /* opcodes operate only on registers */
luai_freeexp(fs, e);
e->u.info = luaK_codeABC(fs, op, 0, r, 0); /* generate opcode */
e->k = LUAI_VRELOCABLE; /* all those operations are relocatable */
luaK_fixline(fs, line);
}
/*
** Emit code for binary expressions that "produce values"
** (everything but logical operators 'and'/'or' and comparison
** operators).
** Expression to produce final result will be encoded in 'e1'.
** Because 'luaK_exp2RK' can free registers, its calls must be
** in "stack order" (that is, first on 'e2', which may have more
** recent registers to be released).
*/
static void luai_codebinexpval (luai_FuncState *fs, luai_OpCode op,
luai_expdesc *e1, luai_expdesc *e2, int line) {
int rk2 = luaK_exp2RK(fs, e2); /* both operands are "RK" */
int rk1 = luaK_exp2RK(fs, e1);
luai_freeexps(fs, e1, e2);
e1->u.info = luaK_codeABC(fs, op, 0, rk1, rk2); /* generate opcode */
e1->k = LUAI_VRELOCABLE; /* all those operations are relocatable */
luaK_fixline(fs, line);
}
/*
** Emit code for comparisons.
** 'e1' was already put in R/K form by 'luaK_infix'.
*/
static void luai_codecomp (luai_FuncState *fs, luai_BinOpr opr, luai_expdesc *e1, luai_expdesc *e2) {
int rk1 = (e1->k == LUAI_VK) ? luai_RKASK(e1->u.info)
: luai_check_exp(e1->k == LUAI_VNONRELOC, e1->u.info);
int rk2 = luaK_exp2RK(fs, e2);
luai_freeexps(fs, e1, e2);
switch (opr) {
case LUAI_OPRNE: { /* '(a ~= b)' ==> 'not (a == b)' */
e1->u.info = luai_condjump(fs, luai_OP_EQ, 0, rk1, rk2);
break;
}
case LUAI_OPRGT: case LUAI_OPRGE: {
/* '(a > b)' ==> '(b < a)'; '(a >= b)' ==> '(b <= a)' */
luai_OpCode op = luai_cast(luai_OpCode, (opr - LUAI_OPRNE) + luai_OP_EQ);
e1->u.info = luai_condjump(fs, op, 1, rk2, rk1); /* invert operands */
break;
}
default: { /* '==', '<', '<=' use their own opcodes */
luai_OpCode op = luai_cast(luai_OpCode, (opr - LUAI_OPREQ) + luai_OP_EQ);
e1->u.info = luai_condjump(fs, op, 1, rk1, rk2);
break;
}
}
e1->k = LUAI_VJMP;
}
/*
** Aplly prefix operation 'op' to expression 'e'.
*/
void luaK_prefix (luai_FuncState *fs, laui_UnOpr op, luai_expdesc *e, int line) {
static const luai_expdesc ef = {LUAI_VKINT, {0}, LUAI_NO_JUMP, LUAI_NO_JUMP};
switch (op) {
case LUAI_OPRMINUS: case LUAI_OPRBNOT: /* use 'ef' as fake 2nd operand */
if (luai_constfolding(fs, op + LUA_OPUNM, e, &ef))
break;
/* FALLTHROUGH */
case LUAI_OPRLEN:
luai_codeunexpval(fs, luai_cast(luai_OpCode, op + luai_OP_UNM), e, line);
break;
case LUAI_OPRNOT: luai_codenot(fs, e); break;
default: lua_assert(0);
}
}
/*
** Process 1st operand 'v' of binary operation 'op' before reading
** 2nd operand.
*/
void luaK_infix (luai_FuncState *fs, luai_BinOpr op, luai_expdesc *v) {
switch (op) {
case LUAI_OPRAND: {
luaK_goiftrue(fs, v); /* go ahead only if 'v' is true */
break;
}
case LUAI_OPROR: {
luaK_goiffalse(fs, v); /* go ahead only if 'v' is false */
break;
}
case LUAI_OPRCONCAT: {
luaK_exp2nextreg(fs, v); /* operand must be on the 'stack' */
break;
}
case LUAI_OPRADD: case LUAI_OPRSUB:
case LUAI_OPRMUL: case LUAI_OPRDIV: case LUAI_OPRIDIV:
case LUAI_OPRMOD: case LUAI_OPRPOW:
case LUAI_OPRBAND: case LUAI_OPRBOR: case LUAI_OPRBXOR:
case LUAI_OPRSHL: case LUAI_OPRSHR: {
if (!lua_tonumeral(v, NULL))
luaK_exp2RK(fs, v);
/* else keep numeral, which may be folded with 2nd operand */
break;
}
default: {
luaK_exp2RK(fs, v);
break;
}
}
}
/*
** Finalize code for binary operation, after reading 2nd operand.
** For '(a .. b .. c)' (which is '(a .. (b .. c))', because
** concatenation is right associative), merge second CONCAT into first
** one.
*/
void luaK_posfix (luai_FuncState *fs, luai_BinOpr op,
luai_expdesc *e1, luai_expdesc *e2, int line) {
switch (op) {
case LUAI_OPRAND: {
lua_assert(e1->t == LUAI_NO_JUMP); /* list closed by 'luK_infix' */
luaK_dischargevars(fs, e2);
luaK_concat(fs, &e2->f, e1->f);
*e1 = *e2;
break;
}
case LUAI_OPROR: {
lua_assert(e1->f == LUAI_NO_JUMP); /* list closed by 'luK_infix' */
luaK_dischargevars(fs, e2);
luaK_concat(fs, &e2->t, e1->t);
*e1 = *e2;
break;
}
case LUAI_OPRCONCAT: {
luaK_exp2val(fs, e2);
if (e2->k == LUAI_VRELOCABLE &&
luai_GETOPCODE(luai_getinstruction(fs, e2)) == luai_OP_CONCAT) {
lua_assert(e1->u.info == luai_GETARG_B(luai_getinstruction(fs, e2))-1);
luai_freeexp(fs, e1);
luai_SETARG_B(luai_getinstruction(fs, e2), e1->u.info);
e1->k = LUAI_VRELOCABLE; e1->u.info = e2->u.info;
}
else {
luaK_exp2nextreg(fs, e2); /* operand must be on the 'stack' */
luai_codebinexpval(fs, luai_OP_CONCAT, e1, e2, line);
}
break;
}
case LUAI_OPRADD: case LUAI_OPRSUB: case LUAI_OPRMUL: case LUAI_OPRDIV:
case LUAI_OPRIDIV: case LUAI_OPRMOD: case LUAI_OPRPOW:
case LUAI_OPRBAND: case LUAI_OPRBOR: case LUAI_OPRBXOR:
case LUAI_OPRSHL: case LUAI_OPRSHR: {
if (!luai_constfolding(fs, op + LUA_OPADD, e1, e2))
luai_codebinexpval(fs, luai_cast(luai_OpCode, op + luai_OP_ADD), e1, e2, line);
break;
}
case LUAI_OPREQ: case LUAI_OPRLT: case LUAI_OPRLE:
case LUAI_OPRNE: case LUAI_OPRGT: case LUAI_OPRGE: {
luai_codecomp(fs, op, e1, e2);
break;
}
default: lua_assert(0);
}
}
/*
** Change line information associated with current position.
*/
void luaK_fixline (luai_FuncState *fs, int line) {
fs->f->lineinfo[fs->pc - 1] = line;
}
/*
** Emit a SETLIST instruction.
** 'base' is register that keeps table;
** 'nelems' is #table plus those to be stored now;
** 'tostore' is number of values (in registers 'base + 1',...) to add to
** table (or LUA_MULTRET to add up to stack top).
*/
void luaK_setlist (luai_FuncState *fs, int base, int nelems, int tostore) {
int c = (nelems - 1)/LUAI_LFIELDS_PER_FLUSH + 1;
int b = (tostore == LUA_MULTRET) ? 0 : tostore;
lua_assert(tostore != 0 && tostore <= LUAI_LFIELDS_PER_FLUSH);
if (c <= luai_MAXARG_C)
luaK_codeABC(fs, luai_OP_SETLIST, base, b, c);
else if (c <= luai_MAXARG_Ax) {
luaK_codeABC(fs, luai_OP_SETLIST, base, b, 0);
luai_codeextraarg(fs, c);
}
else
luaX_syntaxerror(fs->ls, "constructor too long");
fs->luai_freereg = base + 1; /* free registers with list values */
}
/*__lcorlib.c__*/
static lua_State *luai_getco (lua_State *L) {
lua_State *co = lua_tothread(L, 1);
luaL_argcheck(L, co, 1, "thread expected");
return co;
}
static int luai_auxresume (lua_State *L, lua_State *co, int narg) {
int status;
if (!lua_checkstack(co, narg)) {
lua_pushliteral(L, "too many arguments to luai_resume");
return -1; /* error flag */
}
if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) {
lua_pushliteral(L, "cannot luai_resume dead coroutine");
return -1; /* error flag */
}
lua_xmove(L, co, narg);
status = lua_resume(co, L, narg);
if (status == LUA_OK || status == LUA_YIELD) {
int nres = lua_gettop(co);
if (!lua_checkstack(L, nres + 1)) {
lua_pop(co, nres); /* remove results anyway */
lua_pushliteral(L, "too many results to luai_resume");
return -1; /* error flag */
}
lua_xmove(co, L, nres); /* move yielded values */
return nres;
}
else {
lua_xmove(co, L, 1); /* move error message */
return -1; /* error flag */
}
}
static int luaB_coresume (lua_State *L) {
lua_State *co = luai_getco(L);
int r;
r = luai_auxresume(L, co, lua_gettop(L) - 1);
if (r < 0) {
lua_pushboolean(L, 0);
lua_insert(L, -2);
return 2; /* return false + error message */
}
else {
lua_pushboolean(L, 1);
lua_insert(L, -(r + 1));
return r + 1; /* return true + 'luai_resume' returns */
}
}
static int luaB_auxwrap (lua_State *L) {
lua_State *co = lua_tothread(L, lua_upvalueindex(1));
int r = luai_auxresume(L, co, lua_gettop(L));
if (r < 0) {
if (lua_type(L, -1) == LUA_TSTRING) { /* error object is a string? */
luaL_where(L, 1); /* add extra info */
lua_insert(L, -2);
lua_concat(L, 2);
}
return lua_error(L); /* propagate error */
}
return r;
}
static int luaB_cocreate (lua_State *L) {
lua_State *NL;
luaL_checktype(L, 1, LUA_TFUNCTION);
NL = lua_newthread(L);
lua_pushvalue(L, 1); /* move function to top */
lua_xmove(L, NL, 1); /* move function from L to NL */
return 1;
}
static int luaB_cowrap (lua_State *L) {
luaB_cocreate(L);
lua_pushcclosure(L, luaB_auxwrap, 1);
return 1;
}
static int luaB_yield (lua_State *L) {
return lua_yield(L, lua_gettop(L));
}
static int luaB_costatus (lua_State *L) {
lua_State *co = luai_getco(L);
if (L == co) lua_pushliteral(L, "running");
else {
switch (lua_status(co)) {
case LUA_YIELD:
lua_pushliteral(L, "suspended");
break;
case LUA_OK: {
lua_Debug ar;
if (lua_getstack(co, 0, &ar) > 0) /* does it have frames? */
lua_pushliteral(L, "normal"); /* it is running */
else if (lua_gettop(co) == 0)
lua_pushliteral(L, "dead");
else
lua_pushliteral(L, "suspended"); /* initial state */
break;
}
default: /* some error occurred */
lua_pushliteral(L, "dead");
break;
}
}
return 1;
}
static int luaB_yieldable (lua_State *L) {
lua_pushboolean(L, lua_isyieldable(L));
return 1;
}
static int luaB_corunning (lua_State *L) {
int ismain = lua_pushthread(L);
lua_pushboolean(L, ismain);
return 2;
}
static const luaL_Reg luai_co_funcs[] = {
{"create", luaB_cocreate},
{"resume", luaB_coresume},
{"running", luaB_corunning},
{"status", luaB_costatus},
{"wrap", luaB_cowrap},
{"yield", luaB_yield},
{"isyieldable", luaB_yieldable},
{NULL, NULL}
};
LUAMOD_API int luaopen_coroutine (lua_State *L) {
luaL_newlib(L, luai_co_funcs);
return 1;
}
/*__lctype.c__*/
#if !LUA_USE_CTYPE /* { */
#include <limits.h>
LUAI_DDEF const luai_lu_byte luai_ctype_[UCHAR_MAX + 2] = {
0x00, /* LUAI_EOZ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0. */
0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, /* 2. */
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, /* 3. */
0x16, 0x16, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 4. */
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 5. */
0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x05,
0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 6. */
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 7. */
0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 8. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 9. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* a. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* b. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* c. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* d. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* e. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* f. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
#endif /* } */
/*__ldblib.c__*/
/*
** The hook table at registry[&LUAI_HOOKKEY] maps threads to their current
** hook function. (We only need the unique address of 'LUAI_HOOKKEY'.)
*/
static const int LUAI_HOOKKEY = 0;
/*
** If L1 != L, L1 can be in any state, and therefore there are no
** guarantees about its stack space; any push in L1 must be
** checked.
*/
static void luai_checkstack (lua_State *L, lua_State *L1, int n) {
if (L != L1 && !lua_checkstack(L1, n))
luaL_error(L, "stack overflow");
}
static int luai_db_getregistry (lua_State *L) {
lua_pushvalue(L, LUA_REGISTRYINDEX);
return 1;
}
static int luai_db_getmetatable (lua_State *L) {
luaL_checkany(L, 1);
if (!lua_getmetatable(L, 1)) {
lua_pushnil(L); /* no metatable */
}
return 1;
}
static int luai_db_setmetatable (lua_State *L) {
int t = lua_type(L, 2);
luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
"nil or table expected");
lua_settop(L, 2);
lua_setmetatable(L, 1);
return 1; /* return 1st argument */
}
static int luai_db_getuservalue (lua_State *L) {
if (lua_type(L, 1) != LUA_TUSERDATA)
lua_pushnil(L);
else
lua_getuservalue(L, 1);
return 1;
}
static int luai_db_setuservalue (lua_State *L) {
luaL_checktype(L, 1, LUA_TUSERDATA);
luaL_checkany(L, 2);
lua_settop(L, 2);
lua_setuservalue(L, 1);
return 1;
}
/*
** Auxiliary function used by several library functions: luai_check for
** an optional thread as function's first argument and set 'arg' with
** 1 if this argument is present (so that functions can skip it to
** access their other arguments)
*/
static lua_State *luai_getthread (lua_State *L, int *arg) {
if (lua_isthread(L, 1)) {
*arg = 1;
return lua_tothread(L, 1);
}
else {
*arg = 0;
return L; /* function will operate over current thread */
}
}
/*
** Variations of 'lua_settable', used by 'luai_db_getinfo' to put results
** from 'lua_getinfo' into result table. Key is always a string;
** value can be a string, an int, or a boolean.
*/
static void luai_settabss (lua_State *L, const char *k, const char *v) {
lua_pushstring(L, v);
lua_setfield(L, -2, k);
}
static void luai_settabsi (lua_State *L, const char *k, int v) {
lua_pushinteger(L, v);
lua_setfield(L, -2, k);
}
static void luai_settabsb (lua_State *L, const char *k, int v) {
lua_pushboolean(L, v);
lua_setfield(L, -2, k);
}
/*
** In function 'luai_db_getinfo', the call to 'lua_getinfo' may push
** results on the stack; later it creates the result table to put
** these objects. Function 'luai_treatstackoption' puts the result from
** 'lua_getinfo' on top of the result table so that it can call
** 'lua_setfield'.
*/
static void luai_treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
if (L == L1)
lua_rotate(L, -2, 1); /* exchange object and table */
else
lua_xmove(L1, L, 1); /* move object to the "main" stack */
lua_setfield(L, -2, fname); /* put object into table */
}
/*
** Calls 'lua_getinfo' and collects all results in a new table.
** L1 needs stack space for an optional input (function) plus
** two optional outputs (function and line table) from function
** 'lua_getinfo'.
*/
static int luai_db_getinfo (lua_State *L) {
lua_Debug ar;
int arg;
lua_State *L1 = luai_getthread(L, &arg);
const char *options = luaL_optstring(L, arg+2, "flnStu");
luai_checkstack(L, L1, 3);
if (lua_isfunction(L, arg + 1)) { /* info about a function? */
options = lua_pushfstring(L, ">%s", options); /* add '>' to 'options' */
lua_pushvalue(L, arg + 1); /* move function to 'L1' stack */
lua_xmove(L, L1, 1);
}
else { /* stack level */
if (!lua_getstack(L1, (int)luaL_checkinteger(L, arg + 1), &ar)) {
lua_pushnil(L); /* level out of range */
return 1;
}
}
if (!lua_getinfo(L1, options, &ar))
return luaL_argerror(L, arg+2, "invalid option");
lua_newtable(L); /* table to collect results */
if (strchr(options, 'S')) {
luai_settabss(L, "source", ar.source);
luai_settabss(L, "short_src", ar.short_src);
luai_settabsi(L, "linedefined", ar.linedefined);
luai_settabsi(L, "lastlinedefined", ar.lastlinedefined);
luai_settabss(L, "what", ar.what);
}
if (strchr(options, 'l'))
luai_settabsi(L, "currentline", ar.luai_currentline);
if (strchr(options, 'u')) {
luai_settabsi(L, "nups", ar.nups);
luai_settabsi(L, "nparams", ar.nparams);
luai_settabsb(L, "isvararg", ar.isvararg);
}
if (strchr(options, 'n')) {
luai_settabss(L, "name", ar.name);
luai_settabss(L, "namewhat", ar.namewhat);
}
if (strchr(options, 't'))
luai_settabsb(L, "istailcall", ar.istailcall);
if (strchr(options, 'L'))
luai_treatstackoption(L, L1, "activelines");
if (strchr(options, 'f'))
luai_treatstackoption(L, L1, "func");
return 1; /* return table */
}
static int luai_db_getlocal (lua_State *L) {
int arg;
lua_State *L1 = luai_getthread(L, &arg);
lua_Debug ar;
const char *name;
int nvar = (int)luaL_checkinteger(L, arg + 2); /* local-variable index */
if (lua_isfunction(L, arg + 1)) { /* function argument? */
lua_pushvalue(L, arg + 1); /* push function */
lua_pushstring(L, lua_getlocal(L, NULL, nvar)); /* push local name */
return 1; /* return only name (there is no value) */
}
else { /* stack-level argument */
int level = (int)luaL_checkinteger(L, arg + 1);
if (!lua_getstack(L1, level, &ar)) /* out of range? */
return luaL_argerror(L, arg+1, "level out of range");
luai_checkstack(L, L1, 1);
name = lua_getlocal(L1, &ar, nvar);
if (name) {
lua_xmove(L1, L, 1); /* move local value */
lua_pushstring(L, name); /* push name */
lua_rotate(L, -2, 1); /* re-order */
return 2;
}
else {
lua_pushnil(L); /* no name (nor value) */
return 1;
}
}
}
static int luai_db_setlocal (lua_State *L) {
int arg;
const char *name;
lua_State *L1 = luai_getthread(L, &arg);
lua_Debug ar;
int level = (int)luaL_checkinteger(L, arg + 1);
int nvar = (int)luaL_checkinteger(L, arg + 2);
if (!lua_getstack(L1, level, &ar)) /* out of range? */
return luaL_argerror(L, arg+1, "level out of range");
luaL_checkany(L, arg+3);
lua_settop(L, arg+3);
luai_checkstack(L, L1, 1);
lua_xmove(L, L1, 1);
name = lua_setlocal(L1, &ar, nvar);
if (name == NULL)
lua_pop(L1, 1); /* pop value (if not popped by 'lua_setlocal') */
lua_pushstring(L, name);
return 1;
}
/*
** get (if 'get' is true) or set an upvalue from a closure
*/
static int luai_auxupvalue (lua_State *L, int get) {
const char *name;
int n = (int)luaL_checkinteger(L, 2); /* upvalue index */
luaL_checktype(L, 1, LUA_TFUNCTION); /* closure */
name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
if (name == NULL) return 0;
lua_pushstring(L, name);
lua_insert(L, -(get+1)); /* no-op if get is false */
return get + 1;
}
static int luai_db_getupvalue (lua_State *L) {
return luai_auxupvalue(L, 1);
}
static int luai_db_setupvalue (lua_State *L) {
luaL_checkany(L, 3);
return luai_auxupvalue(L, 0);
}
/*
** Check whether a given upvalue from a given closure exists and
** returns its index
*/
static int luai_checkupval (lua_State *L, int argf, int argnup) {
int nup = (int)luaL_checkinteger(L, argnup); /* upvalue index */
luaL_checktype(L, argf, LUA_TFUNCTION); /* closure */
luaL_argcheck(L, (lua_getupvalue(L, argf, nup) != NULL), argnup,
"invalid upvalue index");
return nup;
}
static int luai_db_upvalueid (lua_State *L) {
int n = luai_checkupval(L, 1, 2);
lua_pushlightuserdata(L, lua_upvalueid(L, 1, n));
return 1;
}
static int luai_db_upvaluejoin (lua_State *L) {
int n1 = luai_checkupval(L, 1, 2);
int n2 = luai_checkupval(L, 3, 4);
luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected");
luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected");
lua_upvaluejoin(L, 1, n1, 3, n2);
return 0;
}
/*
** Call hook function registered at hook table for the current
** thread (if there is one)
*/
static void luai_hookf (lua_State *L, lua_Debug *ar) {
static const char *const hooknames[] =
{"call", "return", "line", "count", "tail call"};
lua_rawgetp(L, LUA_REGISTRYINDEX, &LUAI_HOOKKEY);
lua_pushthread(L);
if (lua_rawget(L, -2) == LUA_TFUNCTION) { /* is there a hook function? */
lua_pushstring(L, hooknames[(int)ar->event]); /* push event name */
if (ar->luai_currentline >= 0)
lua_pushinteger(L, ar->luai_currentline); /* push current line */
else lua_pushnil(L);
lua_assert(lua_getinfo(L, "lS", ar));
lua_call(L, 2, 0); /* call hook function */
}
}
/*
** Convert a string mask (for 'sethook') into a bit mask
*/
static int luai_makemask (const char *smask, int count) {
int mask = 0;
if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
if (strchr(smask, 'r')) mask |= LUA_MASKRET;
if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
if (count > 0) mask |= LUA_MASKCOUNT;
return mask;
}
/*
** Convert a bit mask (for 'gethook') into a string mask
*/
static char *luai_unmakemask (int mask, char *smask) {
int i = 0;
if (mask & LUA_MASKCALL) smask[i++] = 'c';
if (mask & LUA_MASKRET) smask[i++] = 'r';
if (mask & LUA_MASKLINE) smask[i++] = 'l';
smask[i] = '\0';
return smask;
}
static int luai_db_sethook (lua_State *L) {
int arg, mask, count;
lua_Hook func;
lua_State *L1 = luai_getthread(L, &arg);
if (lua_isnoneornil(L, arg+1)) { /* no hook? */
lua_settop(L, arg+1);
func = NULL; mask = 0; count = 0; /* turn off hooks */
}
else {
const char *smask = luaL_checkstring(L, arg+2);
luaL_checktype(L, arg+1, LUA_TFUNCTION);
count = (int)luaL_optinteger(L, arg + 3, 0);
func = luai_hookf; mask = luai_makemask(smask, count);
}
if (lua_rawgetp(L, LUA_REGISTRYINDEX, &LUAI_HOOKKEY) == LUA_TNIL) {
lua_createtable(L, 0, 2); /* create a hook table */
lua_pushvalue(L, -1);
lua_rawsetp(L, LUA_REGISTRYINDEX, &LUAI_HOOKKEY); /* set it in position */
lua_pushstring(L, "k");
lua_setfield(L, -2, "__mode"); /** hooktable.__mode = "k" */
lua_pushvalue(L, -1);
lua_setmetatable(L, -2); /* setmetatable(hooktable) = hooktable */
}
luai_checkstack(L, L1, 1);
lua_pushthread(L1); lua_xmove(L1, L, 1); /* key (thread) */
lua_pushvalue(L, arg + 1); /* value (hook function) */
lua_rawset(L, -3); /* hooktable[L1] = new Lua hook */
lua_sethook(L1, func, mask, count);
return 0;
}
static int luai_db_gethook (lua_State *L) {
int arg;
lua_State *L1 = luai_getthread(L, &arg);
char buff[5];
int mask = lua_gethookmask(L1);
lua_Hook hook = lua_gethook(L1);
if (hook == NULL) /* no hook? */
lua_pushnil(L);
else if (hook != luai_hookf) /* external hook? */
lua_pushliteral(L, "external hook");
else { /* hook table must exist */
lua_rawgetp(L, LUA_REGISTRYINDEX, &LUAI_HOOKKEY);
luai_checkstack(L, L1, 1);
lua_pushthread(L1); lua_xmove(L1, L, 1);
lua_rawget(L, -2); /* 1st result = hooktable[L1] */
lua_remove(L, -2); /* remove hook table */
}
lua_pushstring(L, luai_unmakemask(mask, buff)); /* 2nd result = mask */
lua_pushinteger(L, lua_gethookcount(L1)); /* 3rd result = count */
return 3;
}
static int luai_db_debug (lua_State *L) {
for (;;) {
char buffer[250];
lua_writestringerror("%s", "lua_debug> ");
if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
strcmp(buffer, "cont\n") == 0)
return 0;
if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
lua_pcall(L, 0, 0, 0))
lua_writestringerror("%s\n", lua_tostring(L, -1));
lua_settop(L, 0); /* remove eventual returns */
}
}
static int luai_db_traceback (lua_State *L) {
int arg;
lua_State *L1 = luai_getthread(L, &arg);
const char *msg = lua_tostring(L, arg + 1);
if (msg == NULL && !lua_isnoneornil(L, arg + 1)) /* non-string 'msg'? */
lua_pushvalue(L, arg + 1); /* return it untouched */
else {
int level = (int)luaL_optinteger(L, arg + 2, (L == L1) ? 1 : 0);
luaL_traceback(L, L1, msg, level);
}
return 1;
}
static const luaL_Reg luai_dblib[] = {
{"debug", luai_db_debug},
{"getuservalue", luai_db_getuservalue},
{"gethook", luai_db_gethook},
{"getinfo", luai_db_getinfo},
{"getlocal", luai_db_getlocal},
{"getregistry", luai_db_getregistry},
{"getmetatable", luai_db_getmetatable},
{"getupvalue", luai_db_getupvalue},
{"upvaluejoin", luai_db_upvaluejoin},
{"upvalueid", luai_db_upvalueid},
{"setuservalue", luai_db_setuservalue},
{"sethook", luai_db_sethook},
{"setlocal", luai_db_setlocal},
{"setmetatable", luai_db_setmetatable},
{"setupvalue", luai_db_setupvalue},
{"traceback", luai_db_traceback},
{NULL, NULL}
};
LUAMOD_API int luaopen_debug (lua_State *L) {
luaL_newlib(L, luai_dblib);
return 1;
}
/*__ldebug.c__*/
#define lua_noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_TCCL)
/* Active Lua function (given call info) */
#define lua_ci_func(ci) (luai_clLvalue((ci)->func))
static const char *luai_funcnamefromcode (lua_State *L, luai_CallInfo *ci,
const char **name);
static int luai_currentpc (luai_CallInfo *ci) {
lua_assert(luai_isLua(ci));
return luai_pcRel(ci->u.l.savedpc, lua_ci_func(ci)->p);
}
static int luai_currentline (luai_CallInfo *ci) {
return luai_getfuncline(lua_ci_func(ci)->p, luai_currentpc(ci));
}
/*
** If function yielded, its 'func' can be in the 'extra' luai_field. The
** luai_next function restores 'func' to its correct value for debugging
** purposes. (It exchanges 'func' and 'extra'; so, when called again,
** after debugging, it also "re-restores" ** 'func' to its altered value.
*/
static void luai_swapextra (lua_State *L) {
if (L->status == LUA_YIELD) {
luai_CallInfo *ci = L->ci; /* get function that yielded */
luai_StkId temp = ci->func; /* exchange its 'func' and 'extra' values */
ci->func = luai_restorestack(L, ci->extra);
ci->extra = luai_savestack(L, temp);
}
}
/*
** This function can be called asynchronously (e.g. during a signal).
** Fields 'oldpc', 'basehookcount', and 'hookcount' (set by
** 'luai_resethookcount') are for debug only, and it is no problem if they
** get arbitrary values (causes at most one wrong hook call). 'hookmask'
** is an luai_atomic value. We assume that pointers are luai_atomic too (e.g., gcc
** ensures that for all platforms where it runs). Moreover, 'hook' is
** always checked before being called (see 'luaD_hook').
*/
LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
if (func == NULL || mask == 0) { /* turn off hooks? */
mask = 0;
func = NULL;
}
if (luai_isLua(L->ci))
L->oldpc = L->ci->u.l.savedpc;
L->hook = func;
L->basehookcount = count;
luai_resethookcount(L);
L->hookmask = luai_cast_byte(mask);
}
LUA_API lua_Hook lua_gethook (lua_State *L) {
return L->hook;
}
LUA_API int lua_gethookmask (lua_State *L) {
return L->hookmask;
}
LUA_API int lua_gethookcount (lua_State *L) {
return L->basehookcount;
}
LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
int status;
luai_CallInfo *ci;
if (level < 0) return 0; /* invalid (negative) level */
lua_lock(L);
for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous)
level--;
if (level == 0 && ci != &L->base_ci) { /* level found? */
status = 1;
ar->i_ci = ci;
}
else status = 0; /* no such level */
lua_unlock(L);
return status;
}
static const char *luai_upvalname (luai_Proto *p, int uv) {
luai_TString *s = luai_check_exp(uv < p->sizeupvalues, p->upvalues[uv].name);
if (s == NULL) return "?";
else return luai_getstr(s);
}
static const char *luai_findvararg (luai_CallInfo *ci, int n, luai_StkId *pos) {
int nparams = luai_clLvalue(ci->func)->p->numparams;
if (n >= luai_cast_int(ci->u.l.base - ci->func) - nparams)
return NULL; /* no such vararg */
else {
*pos = ci->func + nparams + n;
return "(*vararg)"; /* generic name for any vararg */
}
}
static const char *luai_findlocal (lua_State *L, luai_CallInfo *ci, int n,
luai_StkId *pos) {
const char *name = NULL;
luai_StkId base;
if (luai_isLua(ci)) {
if (n < 0) /* access to vararg values? */
return luai_findvararg(ci, -n, pos);
else {
base = ci->u.l.base;
name = luaF_getlocalname(lua_ci_func(ci)->p, n, luai_currentpc(ci));
}
}
else
base = ci->func + 1;
if (name == NULL) { /* no 'standard' name? */
luai_StkId limit = (ci == L->ci) ? L->top : ci->luai_next->func;
if (limit - base >= n && n > 0) /* is 'n' inside 'ci' stack? */
name = "(*temporary)"; /* generic name for any valid slot */
else
return NULL; /* no name */
}
*pos = base + (n - 1);
return name;
}
LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
const char *name;
lua_lock(L);
luai_swapextra(L);
if (ar == NULL) { /* information about non-active function? */
if (!luai_isLfunction(L->top - 1)) /* not a Lua function? */
name = NULL;
else /* consider live variables at function start (parameters) */
name = luaF_getlocalname(luai_clLvalue(L->top - 1)->p, n, 0);
}
else { /* active function; get information through 'ar' */
luai_StkId pos = NULL; /* to avoid warnings */
name = luai_findlocal(L, ar->i_ci, n, &pos);
if (name) {
luai_setobj2s(L, L->top, pos);
luai_api_incr_top(L);
}
}
luai_swapextra(L);
lua_unlock(L);
return name;
}
LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
luai_StkId pos = NULL; /* to avoid warnings */
const char *name;
lua_lock(L);
luai_swapextra(L);
name = luai_findlocal(L, ar->i_ci, n, &pos);
if (name) {
luai_setobjs2s(L, pos, L->top - 1);
L->top--; /* pop value */
}
luai_swapextra(L);
lua_unlock(L);
return name;
}
static void luai_funcinfo (lua_Debug *ar, luai_Closure *cl) {
if (lua_noLuaClosure(cl)) {
ar->source = "=[C]";
ar->linedefined = -1;
ar->lastlinedefined = -1;
ar->what = "C";
}
else {
luai_Proto *p = cl->l.p;
ar->source = p->source ? luai_getstr(p->source) : "=?";
ar->linedefined = p->linedefined;
ar->lastlinedefined = p->lastlinedefined;
ar->what = (ar->linedefined == 0) ? "main" : "Lua";
}
luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
}
static void luai_collectvalidlines (lua_State *L, luai_Closure *f) {
if (lua_noLuaClosure(f)) {
luai_setnilvalue(L->top);
luai_api_incr_top(L);
}
else {
int i;
luai_TValue v;
int *lineinfo = f->l.p->lineinfo;
luai_Table *t = luaH_new(L); /* new table to store active lines */
luai_sethvalue(L, L->top, t); /* push it on stack */
luai_api_incr_top(L);
luai_setbvalue(&v, 1); /* boolean 'true' to be the value of all indices */
for (i = 0; i < f->l.p->sizelineinfo; i++) /* for all lines with code */
luaH_setint(L, t, lineinfo[i], &v); /* table[line] = true */
}
}
static const char *luai_getfuncname (lua_State *L, luai_CallInfo *ci, const char **name) {
if (ci == NULL) /* no 'ci'? */
return NULL; /* no info */
else if (ci->callstatus & LUAI_CIST_FIN) { /* is this a finalizer? */
*name = "__gc";
return "metamethod"; /* report it as such */
}
/* calling function is a known Lua function? */
else if (!(ci->callstatus & LUAI_CIST_TAIL) && luai_isLua(ci->previous))
return luai_funcnamefromcode(L, ci->previous, name);
else return NULL; /* no way to find a name */
}
static int luai_auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
luai_Closure *f, luai_CallInfo *ci) {
int status = 1;
for (; *what; what++) {
switch (*what) {
case 'S': {
luai_funcinfo(ar, f);
break;
}
case 'l': {
ar->luai_currentline = (ci && luai_isLua(ci)) ? luai_currentline(ci) : -1;
break;
}
case 'u': {
ar->nups = (f == NULL) ? 0 : f->c.nupvalues;
if (lua_noLuaClosure(f)) {
ar->isvararg = 1;
ar->nparams = 0;
}
else {
ar->isvararg = f->l.p->is_vararg;
ar->nparams = f->l.p->numparams;
}
break;
}
case 't': {
ar->istailcall = (ci) ? ci->callstatus & LUAI_CIST_TAIL : 0;
break;
}
case 'n': {
ar->namewhat = luai_getfuncname(L, ci, &ar->name);
if (ar->namewhat == NULL) {
ar->namewhat = ""; /* not found */
ar->name = NULL;
}
break;
}
case 'L':
case 'f': /* handled by lua_getinfo */
break;
default: status = 0; /* invalid option */
}
}
return status;
}
LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
int status;
luai_Closure *cl;
luai_CallInfo *ci;
luai_StkId func;
lua_lock(L);
luai_swapextra(L);
if (*what == '>') {
ci = NULL;
func = L->top - 1;
luai_api_check(L, luai_ttisfunction(func), "function expected");
what++; /* skip the '>' */
L->top--; /* pop function */
}
else {
ci = ar->i_ci;
func = ci->func;
lua_assert(luai_ttisfunction(ci->func));
}
cl = luai_ttisclosure(func) ? luai_clvalue(func) : NULL;
status = luai_auxgetinfo(L, what, ar, cl, ci);
if (strchr(what, 'f')) {
luai_setobjs2s(L, L->top, func);
luai_api_incr_top(L);
}
luai_swapextra(L); /* correct before option 'L', which can raise a mem. error */
if (strchr(what, 'L'))
luai_collectvalidlines(L, cl);
lua_unlock(L);
return status;
}
/*
** {======================================================
** Symbolic Execution
** =======================================================
*/
static const char *luai_getobjname (luai_Proto *p, int lastpc, int reg,
const char **name);
/*
** find a "name" for the RK value 'c'
*/
static void luai_kname (luai_Proto *p, int pc, int c, const char **name) {
if (luai_ISK(c)) { /* is 'c' a constant? */
luai_TValue *kvalue = &p->k[luai_INDEXK(c)];
if (luai_ttisstring(kvalue)) { /* literal constant? */
*name = luai_svalue(kvalue); /* it is its own name */
return;
}
/* else no reasonable name found */
}
else { /* 'c' is a register */
const char *what = luai_getobjname(p, pc, c, name); /* search for 'c' */
if (what && *what == 'c') { /* found a constant name? */
return; /* 'name' already filled */
}
/* else no reasonable name found */
}
*name = "?"; /* no reasonable name found */
}
static int luai_filterpc (int pc, int jmptarget) {
if (pc < jmptarget) /* is code conditional (inside a jump)? */
return -1; /* cannot know who sets that register */
else return pc; /* current position sets that register */
}
/*
** try to find last instruction before 'lastpc' that modified register 'reg'
*/
static int luai_findsetreg (luai_Proto *p, int lastpc, int reg) {
int pc;
int setreg = -1; /* keep last instruction that changed 'reg' */
int jmptarget = 0; /* any code before this address is conditional */
for (pc = 0; pc < lastpc; pc++) {
Instruction i = p->code[pc];
luai_OpCode op = luai_GETOPCODE(i);
int a = luai_GETARG_A(i);
switch (op) {
case luai_OP_LOADNIL: {
int b = luai_GETARG_B(i);
if (a <= reg && reg <= a + b) /* set registers from 'a' to 'a+b' */
setreg = luai_filterpc(pc, jmptarget);
break;
}
case luai_OP_TFORCALL: {
if (reg >= a + 2) /* affect all regs above its base */
setreg = luai_filterpc(pc, jmptarget);
break;
}
case luai_OP_CALL:
case luai_OP_TAILCALL: {
if (reg >= a) /* affect all registers above base */
setreg = luai_filterpc(pc, jmptarget);
break;
}
case luai_OP_JMP: {
int b = luai_GETARG_sBx(i);
int dest = pc + 1 + b;
/* jump is forward and do not skip 'lastpc'? */
if (pc < dest && dest <= lastpc) {
if (dest > jmptarget)
jmptarget = dest; /* update 'jmptarget' */
}
break;
}
default:
if (luai_testAMode(op) && reg == a) /* any instruction that set A */
setreg = luai_filterpc(pc, jmptarget);
break;
}
}
return setreg;
}
static const char *luai_getobjname (luai_Proto *p, int lastpc, int reg,
const char **name) {
int pc;
*name = luaF_getlocalname(p, reg + 1, lastpc);
if (*name) /* is a local? */
return "local";
/* else try symbolic execution */
pc = luai_findsetreg(p, lastpc, reg);
if (pc != -1) { /* could find instruction? */
Instruction i = p->code[pc];
luai_OpCode op = luai_GETOPCODE(i);
switch (op) {
case luai_OP_MOVE: {
int b = luai_GETARG_B(i); /* move from 'b' to 'a' */
if (b < luai_GETARG_A(i))
return luai_getobjname(p, pc, b, name); /* get name for 'b' */
break;
}
case luai_OP_GETTABUP:
case luai_OP_GETTABLE: {
int k = luai_GETARG_C(i); /* key index */
int t = luai_GETARG_B(i); /* table index */
const char *vn = (op == luai_OP_GETTABLE) /* name of indexed variable */
? luaF_getlocalname(p, t + 1, pc)
: luai_upvalname(p, t);
luai_kname(p, pc, k, name);
return (vn && strcmp(vn, LUA_ENV) == 0) ? "global" : "field";
}
case luai_OP_GETUPVAL: {
*name = luai_upvalname(p, luai_GETARG_B(i));
return "upvalue";
}
case luai_OP_LOADK:
case luai_OP_LOADKX: {
int b = (op == luai_OP_LOADK) ? luai_GETARG_Bx(i)
: luai_GETARG_Ax(p->code[pc + 1]);
if (luai_ttisstring(&p->k[b])) {
*name = luai_svalue(&p->k[b]);
return "constant";
}
break;
}
case luai_OP_SELF: {
int k = luai_GETARG_C(i); /* key index */
luai_kname(p, pc, k, name);
return "method";
}
default: break; /* go through to return NULL */
}
}
return NULL; /* could not find reasonable name */
}
/*
** Try to find a name for a function based on the code that called it.
** (Only works when function was called by a Lua function.)
** Returns what the name is (e.g., "for iterator", "method",
** "metamethod") and sets '*name' to point to the name.
*/
static const char *luai_funcnamefromcode (lua_State *L, luai_CallInfo *ci,
const char **name) {
luai_TMS tm = (luai_TMS)0; /* (initial value avoids warnings) */
luai_Proto *p = lua_ci_func(ci)->p; /* calling function */
int pc = luai_currentpc(ci); /* calling instruction index */
Instruction i = p->code[pc]; /* calling instruction */
if (ci->callstatus & LUAI_CIST_HOOKED) { /* was it called inside a hook? */
*name = "?";
return "hook";
}
switch (luai_GETOPCODE(i)) {
case luai_OP_CALL:
case luai_OP_TAILCALL:
return luai_getobjname(p, pc, luai_GETARG_A(i), name); /* get function name */
case luai_OP_TFORCALL: { /* for iterator */
*name = "for iterator";
return "for iterator";
}
/* other instructions can do calls through metamethods */
case luai_OP_SELF: case luai_OP_GETTABUP: case luai_OP_GETTABLE:
tm = LUAI_TM_INDEX;
break;
case luai_OP_SETTABUP: case luai_OP_SETTABLE:
tm = LUAI_TM_NEWINDEX;
break;
case luai_OP_ADD: case luai_OP_SUB: case luai_OP_MUL: case luai_OP_MOD:
case luai_OP_POW: case luai_OP_DIV: case luai_OP_IDIV: case luai_OP_BAND:
case luai_OP_BOR: case luai_OP_BXOR: case luai_OP_SHL: case luai_OP_SHR: {
int offset = luai_cast_int(luai_GETOPCODE(i)) - luai_cast_int(luai_OP_ADD); /* ORDER OP */
tm = luai_cast(luai_TMS, offset + luai_cast_int(LUAI_TM_ADD)); /* ORDER TM */
break;
}
case luai_OP_UNM: tm = LUAI_TM_UNM; break;
case luai_OP_BNOT: tm = LUAI_TM_BNOT; break;
case luai_OP_LEN: tm = LUAI_TM_LEN; break;
case luai_OP_CONCAT: tm = LUAI_TM_CONCAT; break;
case luai_OP_EQ: tm = LUAI_TM_EQ; break;
case luai_OP_LT: tm = LUAI_TM_LT; break;
case luai_OP_LE: tm = LUAI_TM_LE; break;
default:
return NULL; /* cannot find a reasonable name */
}
*name = luai_getstr(LUAI_G(L)->tmname[tm]);
return "metamethod";
}
/* }====================================================== */
/*
** The subtraction of two potentially unrelated pointers is
** not ISO C, but it should not crash a program; the subsequent
** checks are ISO C and ensure a correct result.
*/
static int luai_isinstack (luai_CallInfo *ci, const luai_TValue *o) {
ptrdiff_t i = o - ci->u.l.base;
return (0 <= i && i < (ci->top - ci->u.l.base) && ci->u.l.base + i == o);
}
/*
** Checks whether value 'o' came from an upvalue. (That can only happen
** with instructions luai_OP_GETTABUP/luai_OP_SETTABUP, which operate directly on
** upvalues.)
*/
static const char *luai_getupvalname (luai_CallInfo *ci, const luai_TValue *o,
const char **name) {
luai_LClosure *c = lua_ci_func(ci);
int i;
for (i = 0; i < c->nupvalues; i++) {
if (c->upvals[i]->v == o) {
*name = luai_upvalname(c->p, i);
return "upvalue";
}
}
return NULL;
}
static const char *luai_varinfo (lua_State *L, const luai_TValue *o) {
const char *name = NULL; /* to avoid warnings */
luai_CallInfo *ci = L->ci;
const char *kind = NULL;
if (luai_isLua(ci)) {
kind = luai_getupvalname(ci, o, &name); /* luai_check whether 'o' is an upvalue */
if (!kind && luai_isinstack(ci, o)) /* no? try a register */
kind = luai_getobjname(lua_ci_func(ci)->p, luai_currentpc(ci),
luai_cast_int(o - ci->u.l.base), &name);
}
return (kind) ? luaO_pushfstring(L, " (%s '%s')", kind, name) : "";
}
luai_l_noret luaG_typeerror (lua_State *L, const luai_TValue *o, const char *op) {
const char *t = luaT_objtypename(L, o);
luaG_runerror(L, "attempt to %s a %s value%s", op, t, luai_varinfo(L, o));
}
luai_l_noret luaG_concaterror (lua_State *L, const luai_TValue *p1, const luai_TValue *p2) {
if (luai_ttisstring(p1) || luai_cvt2str(p1)) p1 = p2;
luaG_typeerror(L, p1, "concatenate");
}
luai_l_noret luaG_opinterror (lua_State *L, const luai_TValue *p1,
const luai_TValue *p2, const char *msg) {
lua_Number temp;
if (!luai_tonumber(p1, &temp)) /* first operand is wrong? */
p2 = p1; /* now second is wrong */
luaG_typeerror(L, p2, msg);
}
/*
** Error when both values are convertible to numbers, but not to integers
*/
luai_l_noret luaG_tointerror (lua_State *L, const luai_TValue *p1, const luai_TValue *p2) {
lua_Integer temp;
if (!luai_tointeger(p1, &temp))
p2 = p1;
luaG_runerror(L, "number%s has no integer representation", luai_varinfo(L, p2));
}
luai_l_noret luaG_ordererror (lua_State *L, const luai_TValue *p1, const luai_TValue *p2) {
const char *t1 = luaT_objtypename(L, p1);
const char *t2 = luaT_objtypename(L, p2);
if (strcmp(t1, t2) == 0)
luaG_runerror(L, "attempt to compare two %s values", t1);
else
luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
}
/* add src:line information to 'msg' */
const char *luaG_addinfo (lua_State *L, const char *msg, luai_TString *src,
int line) {
char buff[LUA_IDSIZE];
if (src)
luaO_chunkid(buff, luai_getstr(src), LUA_IDSIZE);
else { /* no source available; use "?" instead */
buff[0] = '?'; buff[1] = '\0';
}
return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
}
luai_l_noret luaG_errormsg (lua_State *L) {
if (L->errfunc != 0) { /* is there an error handling function? */
luai_StkId errfunc = luai_restorestack(L, L->errfunc);
luai_setobjs2s(L, L->top, L->top - 1); /* move argument */
luai_setobjs2s(L, L->top - 1, errfunc); /* push function */
L->top++; /* assume LUAI_EXTRA_STACK */
luaD_callnoyield(L, L->top - 2, 1); /* call it */
}
luaD_throw(L, LUA_ERRRUN);
}
luai_l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
luai_CallInfo *ci = L->ci;
const char *msg;
va_list argp;
va_start(argp, fmt);
msg = luaO_pushvfstring(L, fmt, argp); /* format message */
va_end(argp);
if (luai_isLua(ci)) /* if Lua function, add source:line information */
luaG_addinfo(L, msg, lua_ci_func(ci)->p->source, luai_currentline(ci));
luaG_errormsg(L);
}
void luaG_traceexec (lua_State *L) {
luai_CallInfo *ci = L->ci;
luai_lu_byte mask = L->hookmask;
int counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT));
if (counthook)
luai_resethookcount(L); /* reset count */
else if (!(mask & LUA_MASKLINE))
return; /* no line hook and count != 0; nothing to be done */
if (ci->callstatus & LUAI_CIST_HOOKYIELD) { /* called hook last time? */
ci->callstatus &= ~LUAI_CIST_HOOKYIELD; /* erase mark */
return; /* do not call hook again (VM yielded, so it did not move) */
}
if (counthook)
luaD_hook(L, LUA_HOOKCOUNT, -1); /* call count hook */
if (mask & LUA_MASKLINE) {
luai_Proto *p = lua_ci_func(ci)->p;
int npc = luai_pcRel(ci->u.l.savedpc, p);
int newline = luai_getfuncline(p, npc);
if (npc == 0 || /* call linehook when enter a new function, */
ci->u.l.savedpc <= L->oldpc || /* when jump back (loop), or when */
newline != luai_getfuncline(p, luai_pcRel(L->oldpc, p))) /* enter a new line */
luaD_hook(L, LUA_HOOKLINE, newline); /* call line hook */
}
L->oldpc = ci->u.l.savedpc;
if (L->status == LUA_YIELD) { /* did hook yield? */
if (counthook)
L->hookcount = 1; /* undo decrement to zero */
ci->u.l.savedpc--; /* undo increment (luai_resume will increment it again) */
ci->callstatus |= LUAI_CIST_HOOKYIELD; /* mark that it yielded */
ci->func = L->top - 1; /* protect stack below results */
luaD_throw(L, LUA_YIELD);
}
}
/*__ldo.c__*/
#define errorstatus(s) ((s) > LUA_YIELD)
/*
** {======================================================
** Error-recovery functions
** =======================================================
*/
/*
** LUAI_THROW/LUAI_TRY define how Lua does exception handling. By
** default, Lua handles errors with exceptions when compiling as
** C++ code, with _longjmp/_setjmp when asked to use them, and with
** longjmp/setjmp otherwise.
*/
#if !defined(LUAI_THROW) /* { */
#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP) /* { */
/* C++ exceptions */
#define LUAI_THROW(L,c) throw(c)
#define LUAI_TRY(L,c,a) \
try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }
#define luai_jmpbuf int /* dummy variable */
#elif defined(LUA_USE_POSIX) /* }{ */
/* in POSIX, try _longjmp/_setjmp (more efficient) */
#define LUAI_THROW(L,c) _longjmp((c)->b, 1)
#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }
#define luai_jmpbuf jmp_buf
#else /* }{ */
/* ISO C handling with long jumps */
#define LUAI_THROW(L,c) longjmp((c)->b, 1)
#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }
#define luai_jmpbuf jmp_buf
#endif /* } */
#endif /* } */
/* chain list of long jump buffers */
struct lua_longjmp {
struct lua_longjmp *previous;
luai_jmpbuf b;
volatile int status; /* error code */
};
static void luai_seterrorobj (lua_State *L, int errcode, luai_StkId oldtop) {
switch (errcode) {
case LUA_ERRMEM: { /* memory error? */
luai_setsvalue2s(L, oldtop, LUAI_G(L)->memerrmsg); /* reuse preregistered msg. */
break;
}
case LUA_ERRERR: {
luai_setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
break;
}
default: {
luai_setobjs2s(L, oldtop, L->top - 1); /* error message on current top */
break;
}
}
L->top = oldtop + 1;
}
luai_l_noret luaD_throw (lua_State *L, int errcode) {
if (L->errorJmp) { /* thread has an error handler? */
L->errorJmp->status = errcode; /* set status */
LUAI_THROW(L, L->errorJmp); /* jump to it */
}
else { /* thread has no error handler */
luai_global_State *g = LUAI_G(L);
L->status = luai_cast_byte(errcode); /* mark it as dead */
if (g->mainthread->errorJmp) { /* main thread has a handler? */
luai_setobjs2s(L, g->mainthread->top++, L->top - 1); /* copy error obj. */
luaD_throw(g->mainthread, errcode); /* re-throw in main thread */
}
else { /* no handler at all; abort */
if (g->panic) { /* panic function? */
luai_seterrorobj(L, errcode, L->top); /* assume LUAI_EXTRA_STACK */
if (L->ci->top < L->top)
L->ci->top = L->top; /* pushing msg. can break this invariant */
lua_unlock(L);
g->panic(L); /* call panic function (last chance to jump out) */
}
abort();
}
}
}
int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
unsigned short oldnCcalls = L->nCcalls;
struct lua_longjmp lj;
lj.status = LUA_OK;
lj.previous = L->errorJmp; /* chain new error handler */
L->errorJmp = &lj;
LUAI_TRY(L, &lj,
(*f)(L, ud);
);
L->errorJmp = lj.previous; /* restore old error handler */
L->nCcalls = oldnCcalls;
return lj.status;
}
/* }====================================================== */
/*
** {==================================================================
** Stack reallocation
** ===================================================================
*/
static void luai_correctstack (lua_State *L, luai_TValue *oldstack) {
luai_CallInfo *ci;
luai_UpVal *up;
L->top = (L->top - oldstack) + L->stack;
for (up = L->openupval; up != NULL; up = up->u.open.luai_next)
up->v = (up->v - oldstack) + L->stack;
for (ci = L->ci; ci != NULL; ci = ci->previous) {
ci->top = (ci->top - oldstack) + L->stack;
ci->func = (ci->func - oldstack) + L->stack;
if (luai_isLua(ci))
ci->u.l.base = (ci->u.l.base - oldstack) + L->stack;
}
}
/* some space for error handling */
#define ERRORSTACKSIZE (LUAI_MAXSTACK + 200)
void luaD_reallocstack (lua_State *L, int newsize) {
luai_TValue *oldstack = L->stack;
int lim = L->stacksize;
lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);
lua_assert(L->stack_last - L->stack == L->stacksize - LUAI_EXTRA_STACK);
luaM_reallocvector(L, L->stack, L->stacksize, newsize, luai_TValue);
for (; lim < newsize; lim++)
luai_setnilvalue(L->stack + lim); /* erase new segment */
L->stacksize = newsize;
L->stack_last = L->stack + newsize - LUAI_EXTRA_STACK;
luai_correctstack(L, oldstack);
}
void luaD_growstack (lua_State *L, int n) {
int size = L->stacksize;
if (size > LUAI_MAXSTACK) /* error after extra size? */
luaD_throw(L, LUA_ERRERR);
else {
int needed = luai_cast_int(L->top - L->stack) + n + LUAI_EXTRA_STACK;
int newsize = 2 * size;
if (newsize > LUAI_MAXSTACK) newsize = LUAI_MAXSTACK;
if (newsize < needed) newsize = needed;
if (newsize > LUAI_MAXSTACK) { /* stack overflow? */
luaD_reallocstack(L, ERRORSTACKSIZE);
luaG_runerror(L, "stack overflow");
}
else
luaD_reallocstack(L, newsize);
}
}
static int luai_stackinuse (lua_State *L) {
luai_CallInfo *ci;
luai_StkId lim = L->top;
for (ci = L->ci; ci != NULL; ci = ci->previous) {
if (lim < ci->top) lim = ci->top;
}
lua_assert(lim <= L->stack_last);
return luai_cast_int(lim - L->stack) + 1; /* part of stack in use */
}
void luaD_shrinkstack (lua_State *L) {
int inuse = luai_stackinuse(L);
int goodsize = inuse + (inuse / 8) + 2*LUAI_EXTRA_STACK;
if (goodsize > LUAI_MAXSTACK)
goodsize = LUAI_MAXSTACK; /* respect stack limit */
if (L->stacksize > LUAI_MAXSTACK) /* had been handling stack overflow? */
luaE_freeCI(L); /* free all CIs (list grew because of an error) */
else
luaE_shrinkCI(L); /* shrink list */
/* if thread is currently not handling a stack overflow and its
good size is smaller than current size, shrink its stack */
if (inuse <= (LUAI_MAXSTACK - LUAI_EXTRA_STACK) &&
goodsize < L->stacksize)
luaD_reallocstack(L, goodsize);
else /* don't change stack */
luai_condmovestack(L,{},{}); /* (change only for debugging) */
}
void luaD_inctop (lua_State *L) {
luaD_checkstack(L, 1);
L->top++;
}
/* }================================================================== */
/*
** Call a hook for the given event. Make sure there is a hook to be
** called. (Both 'L->hook' and 'L->hookmask', which triggers this
** function, can be changed asynchronously by signals.)
*/
void luaD_hook (lua_State *L, int event, int line) {
lua_Hook hook = L->hook;
if (hook && L->allowhook) { /* make sure there is a hook */
luai_CallInfo *ci = L->ci;
ptrdiff_t top = luai_savestack(L, L->top);
ptrdiff_t ci_top = luai_savestack(L, ci->top);
lua_Debug ar;
ar.event = event;
ar.luai_currentline = line;
ar.i_ci = ci;
luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
ci->top = L->top + LUA_MINSTACK;
lua_assert(ci->top <= L->stack_last);
L->allowhook = 0; /* cannot call hooks inside a hook */
ci->callstatus |= LUAI_CIST_HOOKED;
lua_unlock(L);
(*hook)(L, &ar);
lua_lock(L);
lua_assert(!L->allowhook);
L->allowhook = 1;
ci->top = luai_restorestack(L, ci_top);
L->top = luai_restorestack(L, top);
ci->callstatus &= ~LUAI_CIST_HOOKED;
}
}
static void luai_callhook (lua_State *L, luai_CallInfo *ci) {
int hook = LUA_HOOKCALL;
ci->u.l.savedpc++; /* hooks assume 'pc' is already incremented */
if (luai_isLua(ci->previous) &&
luai_GETOPCODE(*(ci->previous->u.l.savedpc - 1)) == luai_OP_TAILCALL) {
ci->callstatus |= LUAI_CIST_TAIL;
hook = LUA_HOOKTAILCALL;
}
luaD_hook(L, hook, -1);
ci->u.l.savedpc--; /* correct 'pc' */
}
static luai_StkId luai_adjust_varargs (lua_State *L, luai_Proto *p, int actual) {
int i;
int nfixargs = p->numparams;
luai_StkId base, fixed;
/* move fixed parameters to final position */
fixed = L->top - actual; /* first fixed argument */
base = L->top; /* final position of first argument */
for (i = 0; i < nfixargs && i < actual; i++) {
luai_setobjs2s(L, L->top++, fixed + i);
luai_setnilvalue(fixed + i); /* erase original copy (for LUAI_GC) */
}
for (; i < nfixargs; i++)
luai_setnilvalue(L->top++); /* complete missing arguments */
return base;
}
/*
** Check whether __call metafield of 'func' is a function. If so, put
** it in stack below original 'func' so that 'luaD_precall' can call
** it. Raise an error if __call metafield is not a function.
*/
static void luai_tryfuncTM (lua_State *L, luai_StkId func) {
const luai_TValue *tm = luaT_gettmbyobj(L, func, LUAI_TM_CALL);
luai_StkId p;
if (!luai_ttisfunction(tm))
luaG_typeerror(L, func, "call");
/* Open a hole inside the stack at 'func' */
for (p = L->top; p > func; p--)
luai_setobjs2s(L, p, p-1);
L->top++; /* slot ensured by caller */
luai_setobj2s(L, func, tm); /* tag method is the new function to be called */
}
/*
** Given 'nres' results at 'firstResult', move 'wanted' of them to 'res'.
** Handle most typical cases (zero results for commands, one result for
** expressions, multiple results for tail calls/single parameters)
** separated.
*/
static int luai_moveresults (lua_State *L, const luai_TValue *firstResult, luai_StkId res,
int nres, int wanted) {
switch (wanted) { /* handle typical cases separately */
case 0: break; /* nothing to move */
case 1: { /* one result needed */
if (nres == 0) /* no results? */
firstResult = luaO_nilobject; /* adjust with nil */
luai_setobjs2s(L, res, firstResult); /* move it to proper place */
break;
}
case LUA_MULTRET: {
int i;
for (i = 0; i < nres; i++) /* move all results to correct place */
luai_setobjs2s(L, res + i, firstResult + i);
L->top = res + nres;
return 0; /* wanted == LUA_MULTRET */
}
default: {
int i;
if (wanted <= nres) { /* enough results? */
for (i = 0; i < wanted; i++) /* move wanted results to correct place */
luai_setobjs2s(L, res + i, firstResult + i);
}
else { /* not enough results; use all of them plus nils */
for (i = 0; i < nres; i++) /* move all results to correct place */
luai_setobjs2s(L, res + i, firstResult + i);
for (; i < wanted; i++) /* complete wanted number of results */
luai_setnilvalue(res + i);
}
break;
}
}
L->top = res + wanted; /* top points after the last result */
return 1;
}
/*
** Finishes a function call: calls hook if necessary, removes luai_CallInfo,
** moves current number of results to proper place; returns 0 iff call
** wanted multiple (variable number of) results.
*/
int luaD_poscall (lua_State *L, luai_CallInfo *ci, luai_StkId firstResult, int nres) {
luai_StkId res;
int wanted = ci->nresults;
if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) {
if (L->hookmask & LUA_MASKRET) {
ptrdiff_t fr = luai_savestack(L, firstResult); /* hook may change stack */
luaD_hook(L, LUA_HOOKRET, -1);
firstResult = luai_restorestack(L, fr);
}
L->oldpc = ci->previous->u.l.savedpc; /* 'oldpc' for caller function */
}
res = ci->func; /* res == final position of 1st result */
L->ci = ci->previous; /* back to caller */
/* move results to proper place */
return luai_moveresults(L, firstResult, res, nres, wanted);
}
#define next_ci(L) (L->ci = (L->ci->luai_next ? L->ci->luai_next : luaE_extendCI(L)))
/* macro to luai_check stack size, preserving 'p' */
#define checkstackp(L,n,p) \
luaD_checkstackaux(L, n, \
ptrdiff_t t__ = luai_savestack(L, p); /* luai_save 'p' */ \
luaC_checkGC(L), /* stack grow uses memory */ \
p = luai_restorestack(L, t__)) /* 'pos' part: restore 'p' */
/*
** Prepares a function call: checks the stack, creates a new luai_CallInfo
** entry, fills in the relevant information, calls hook if needed.
** If function is a C function, does the call, too. (Otherwise, leave
** the execution ('luaV_execute') to the caller, to allow stackless
** calls.) Returns true iff function has been executed (C function).
*/
int luaD_precall (lua_State *L, luai_StkId func, int nresults) {
lua_CFunction f;
luai_CallInfo *ci;
switch (luai_ttype(func)) {
case LUA_TCCL: /* C closure */
f = luai_clCvalue(func)->f;
goto Cfunc;
case LUA_TLCF: /* light C function */
f = luai_fvalue(func);
Cfunc: {
int n; /* number of returns */
checkstackp(L, LUA_MINSTACK, func); /* ensure minimum stack size */
ci = next_ci(L); /* now 'enter' new function */
ci->nresults = nresults;
ci->func = func;
ci->top = L->top + LUA_MINSTACK;
lua_assert(ci->top <= L->stack_last);
ci->callstatus = 0;
if (L->hookmask & LUA_MASKCALL)
luaD_hook(L, LUA_HOOKCALL, -1);
lua_unlock(L);
n = (*f)(L); /* do the actual call */
lua_lock(L);
luai_api_checknelems(L, n);
luaD_poscall(L, ci, L->top - n, n);
return 1;
}
case LUA_TLCL: { /* Lua function: prepare its call */
luai_StkId base;
luai_Proto *p = luai_clLvalue(func)->p;
int n = luai_cast_int(L->top - func) - 1; /* number of real arguments */
int fsize = p->maxstacksize; /* frame size */
checkstackp(L, fsize, func);
if (p->is_vararg)
base = luai_adjust_varargs(L, p, n);
else { /* non vararg function */
for (; n < p->numparams; n++)
luai_setnilvalue(L->top++); /* complete missing arguments */
base = func + 1;
}
ci = next_ci(L); /* now 'enter' new function */
ci->nresults = nresults;
ci->func = func;
ci->u.l.base = base;
L->top = ci->top = base + fsize;
lua_assert(ci->top <= L->stack_last);
ci->u.l.savedpc = p->code; /* starting point */
ci->callstatus = LUAI_CIST_LUA;
if (L->hookmask & LUA_MASKCALL)
luai_callhook(L, ci);
return 0;
}
default: { /* not a function */
checkstackp(L, 1, func); /* ensure space for metamethod */
luai_tryfuncTM(L, func); /* try to get '__call' metamethod */
return luaD_precall(L, func, nresults); /* now it must be a function */
}
}
}
/*
** Check appropriate error for stack overflow ("regular" overflow or
** overflow while handling stack overflow). If 'nCalls' is larger than
** LUAI_MAXCCALLS (which means it is handling a "regular" overflow) but
** smaller than 9/8 of LUAI_MAXCCALLS, does not report an error (to
** allow overflow handling to work)
*/
static void luai_stackerror (lua_State *L) {
if (L->nCcalls == LUAI_MAXCCALLS)
luaG_runerror(L, "C stack overflow");
else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
luaD_throw(L, LUA_ERRERR); /* error while handing stack error */
}
/*
** Call a function (C or Lua). The function to be called is at *func.
** The arguments are on the stack, right after the function.
** When returns, all the results are on the stack, starting at the original
** function position.
*/
void luaD_call (lua_State *L, luai_StkId func, int nResults) {
if (++L->nCcalls >= LUAI_MAXCCALLS)
luai_stackerror(L);
if (!luaD_precall(L, func, nResults)) /* is a Lua function? */
luaV_execute(L); /* call it */
L->nCcalls--;
}
/*
** Similar to 'luaD_call', but does not allow yields during the call
*/
void luaD_callnoyield (lua_State *L, luai_StkId func, int nResults) {
L->nny++;
luaD_call(L, func, nResults);
L->nny--;
}
/*
** Completes the execution of an interrupted C function, calling its
** continuation function.
*/
static void luai_finishCcall (lua_State *L, int status) {
luai_CallInfo *ci = L->ci;
int n;
/* must have a continuation and must be able to call it */
lua_assert(ci->u.c.k != NULL && L->nny == 0);
/* error status can only happen in a protected call */
lua_assert((ci->callstatus & LUAI_CIST_YPCALL) || status == LUA_YIELD);
if (ci->callstatus & LUAI_CIST_YPCALL) { /* was inside a pcall? */
ci->callstatus &= ~LUAI_CIST_YPCALL; /* continuation is also inside it */
L->errfunc = ci->u.c.old_errfunc; /* with the same error function */
}
/* finish 'lua_callk'/'lua_pcall'; LUAI_CIST_YPCALL and 'errfunc' already
handled */
luai_adjustresults(L, ci->nresults);
lua_unlock(L);
n = (*ci->u.c.k)(L, status, ci->u.c.ctx); /* call continuation function */
lua_lock(L);
luai_api_checknelems(L, n);
luaD_poscall(L, ci, L->top - n, n); /* finish 'luaD_precall' */
}
/*
** Executes "full continuation" (everything in the stack) of a
** previously interrupted coroutine until the stack is empty (or another
** interruption long-jumps out of the loop). If the coroutine is
** recovering from an error, 'ud' points to the error status, which must
** be passed to the first continuation function (otherwise the default
** status is LUA_YIELD).
*/
static void luai_unroll (lua_State *L, void *ud) {
if (ud != NULL) /* error status? */
luai_finishCcall(L, *(int *)ud); /* finish 'lua_pcallk' callee */
while (L->ci != &L->base_ci) { /* something in the stack */
if (!luai_isLua(L->ci)) /* C function? */
luai_finishCcall(L, LUA_YIELD); /* complete its execution */
else { /* Lua function */
luaV_finishOp(L); /* finish interrupted instruction */
luaV_execute(L); /* execute down to higher C 'boundary' */
}
}
}
/*
** Try to find a suspended protected call (a "recover point") for the
** given thread.
*/
static luai_CallInfo *luai_findpcall (lua_State *L) {
luai_CallInfo *ci;
for (ci = L->ci; ci != NULL; ci = ci->previous) { /* search for a pcall */
if (ci->callstatus & LUAI_CIST_YPCALL)
return ci;
}
return NULL; /* no pending pcall */
}
/*
** Recovers from an error in a coroutine. Finds a luai_recover point (if
** there is one) and completes the execution of the interrupted
** 'luaD_pcall'. If there is no luai_recover point, returns zero.
*/
static int luai_recover (lua_State *L, int status) {
luai_StkId oldtop;
luai_CallInfo *ci = luai_findpcall(L);
if (ci == NULL) return 0; /* no recovery point */
/* "finish" luaD_pcall */
oldtop = luai_restorestack(L, ci->extra);
luaF_close(L, oldtop);
luai_seterrorobj(L, status, oldtop);
L->ci = ci;
L->allowhook = luai_getoah(ci->callstatus); /* restore original 'allowhook' */
L->nny = 0; /* should be zero to be yieldable */
luaD_shrinkstack(L);
L->errfunc = ci->u.c.old_errfunc;
return 1; /* continue running the coroutine */
}
/*
** Signal an error in the call to 'lua_resume', not in the execution
** of the coroutine itself. (Such errors should not be handled by any
** coroutine error handler and should not kill the coroutine.)
*/
static int luai_resume_error (lua_State *L, const char *msg, int narg) {
L->top -= narg; /* remove args from the stack */
luai_setsvalue2s(L, L->top, luaS_new(L, msg)); /* push error message */
luai_api_incr_top(L);
lua_unlock(L);
return LUA_ERRRUN;
}
/*
** Do the work for 'lua_resume' in protected mode. Most of the work
** depends on the status of the coroutine: initial state, suspended
** inside a hook, or regularly suspended (optionally with a continuation
** function), plus erroneous cases: non-suspended coroutine or dead
** coroutine.
*/
static void luai_resume (lua_State *L, void *ud) {
int n = *(luai_cast(int*, ud)); /* number of arguments */
luai_StkId firstArg = L->top - n; /* first argument */
luai_CallInfo *ci = L->ci;
if (L->status == LUA_OK) { /* starting a coroutine? */
if (!luaD_precall(L, firstArg - 1, LUA_MULTRET)) /* Lua function? */
luaV_execute(L); /* call it */
}
else { /* resuming from previous yield */
lua_assert(L->status == LUA_YIELD);
L->status = LUA_OK; /* mark that it is running (again) */
ci->func = luai_restorestack(L, ci->extra);
if (luai_isLua(ci)) /* yielded inside a hook? */
luaV_execute(L); /* just continue running Lua code */
else { /* 'common' yield */
if (ci->u.c.k != NULL) { /* does it have a continuation function? */
lua_unlock(L);
n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */
lua_lock(L);
luai_api_checknelems(L, n);
firstArg = L->top - n; /* yield results come from continuation */
}
luaD_poscall(L, ci, firstArg, n); /* finish 'luaD_precall' */
}
luai_unroll(L, NULL); /* run continuation */
}
}
LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
int status;
unsigned short oldnny = L->nny; /* luai_save "number of non-yieldable" calls */
lua_lock(L);
if (L->status == LUA_OK) { /* may be starting a coroutine */
if (L->ci != &L->base_ci) /* not in base level? */
return luai_resume_error(L, "cannot luai_resume non-suspended coroutine", nargs);
}
else if (L->status != LUA_YIELD)
return luai_resume_error(L, "cannot luai_resume dead coroutine", nargs);
L->nCcalls = (from) ? from->nCcalls + 1 : 1;
if (L->nCcalls >= LUAI_MAXCCALLS)
return luai_resume_error(L, "C stack overflow", nargs);
luai_userstateresume(L, nargs);
L->nny = 0; /* allow yields */
luai_api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs);
status = luaD_rawrunprotected(L, luai_resume, &nargs);
if (status == -1) /* error calling 'lua_resume'? */
status = LUA_ERRRUN;
else { /* continue running after recoverable errors */
while (errorstatus(status) && luai_recover(L, status)) {
/* luai_unroll continuation */
status = luaD_rawrunprotected(L, luai_unroll, &status);
}
if (errorstatus(status)) { /* unrecoverable error? */
L->status = luai_cast_byte(status); /* mark thread as 'dead' */
luai_seterrorobj(L, status, L->top); /* push error message */
L->ci->top = L->top;
}
else lua_assert(status == L->status); /* normal end or yield */
}
L->nny = oldnny; /* restore 'nny' */
L->nCcalls--;
lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
lua_unlock(L);
return status;
}
LUA_API int lua_isyieldable (lua_State *L) {
return (L->nny == 0);
}
LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx,
lua_KFunction k) {
luai_CallInfo *ci = L->ci;
luai_userstateyield(L, nresults);
lua_lock(L);
luai_api_checknelems(L, nresults);
if (L->nny > 0) {
if (L != LUAI_G(L)->mainthread)
luaG_runerror(L, "attempt to yield across a C-call boundary");
else
luaG_runerror(L, "attempt to yield from outside a coroutine");
}
L->status = LUA_YIELD;
ci->extra = luai_savestack(L, ci->func); /* luai_save current 'func' */
if (luai_isLua(ci)) { /* inside a hook? */
luai_api_check(L, k == NULL, "hooks cannot continue after yielding");
}
else {
if ((ci->u.c.k = k) != NULL) /* is there a continuation? */
ci->u.c.ctx = ctx; /* luai_save context */
ci->func = L->top - nresults - 1; /* protect stack below results */
luaD_throw(L, LUA_YIELD);
}
lua_assert(ci->callstatus & LUAI_CIST_HOOKED); /* must be inside a hook */
lua_unlock(L);
return 0; /* return to 'luaD_hook' */
}
int luaD_pcall (lua_State *L, Pfunc func, void *u,
ptrdiff_t old_top, ptrdiff_t ef) {
int status;
luai_CallInfo *old_ci = L->ci;
luai_lu_byte old_allowhooks = L->allowhook;
unsigned short old_nny = L->nny;
ptrdiff_t old_errfunc = L->errfunc;
L->errfunc = ef;
status = luaD_rawrunprotected(L, func, u);
if (status != LUA_OK) { /* an error occurred? */
luai_StkId oldtop = luai_restorestack(L, old_top);
luaF_close(L, oldtop); /* close possible pending closures */
luai_seterrorobj(L, status, oldtop);
L->ci = old_ci;
L->allowhook = old_allowhooks;
L->nny = old_nny;
luaD_shrinkstack(L);
}
L->errfunc = old_errfunc;
return status;
}
/*
** Execute a protected parser.
*/
struct luai_SParser { /* data to 'luai_f_parser' */
LUAI_ZIO *z;
luai_Mbuffer buff; /* dynamic structure used by the scanner */
luai_Dyndata dyd; /* dynamic structures used by the parser */
const char *mode;
const char *name;
};
static void luai_checkmode (lua_State *L, const char *mode, const char *x) {
if (mode && strchr(mode, x[0]) == NULL) {
luaO_pushfstring(L,
"attempt to load a %s chunk (mode is '%s')", x, mode);
luaD_throw(L, LUA_ERRSYNTAX);
}
}
static void luai_f_parser (lua_State *L, void *ud) {
luai_LClosure *cl;
struct luai_SParser *p = luai_cast(struct luai_SParser *, ud);
int c = luai_zgetc(p->z); /* read first character */
if (c == LUA_SIGNATURE[0]) {
luai_checkmode(L, p->mode, "binary");
cl = luaU_undump(L, p->z, p->name);
}
else {
luai_checkmode(L, p->mode, "text");
cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
}
lua_assert(cl->nupvalues == cl->p->sizeupvalues);
luaF_initupvals(L, cl);
}
int luaD_protectedparser (lua_State *L, LUAI_ZIO *z, const char *name,
const char *mode) {
struct luai_SParser p;
int status;
L->nny++; /* cannot yield during parsing */
p.z = z; p.name = name; p.mode = mode;
p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0;
p.dyd.gt.arr = NULL; p.dyd.gt.size = 0;
p.dyd.label.arr = NULL; p.dyd.label.size = 0;
luaZ_initbuffer(L, &p.buff);
status = luaD_pcall(L, luai_f_parser, &p, luai_savestack(L, L->top), L->errfunc);
luaZ_freebuffer(L, &p.buff);
luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size);
luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size);
luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size);
L->nny--;
return status;
}
/*__ldump.c__*/
typedef struct {
lua_State *L;
lua_Writer luai_writer;
void *data;
int strip;
int status;
} luai_DumpState;
/*
** All high-level dumps go through luai_DumpVector; you can change it to
** change the endianness of the result
*/
#define luai_DumpVector(v,n,D) luai_DumpBlock(v,(n)*sizeof((v)[0]),D)
#define luai_DumpLiteral(s,D) luai_DumpBlock(s, sizeof(s) - sizeof(char), D)
static void luai_DumpBlock (const void *b, size_t size, luai_DumpState *D) {
if (D->status == 0 && size > 0) {
lua_unlock(D->L);
D->status = (*D->luai_writer)(D->L, b, size, D->data);
lua_lock(D->L);
}
}
#define luai_DumpVar(x,D) luai_DumpVector(&x,1,D)
static void luai_DumpByte (int y, luai_DumpState *D) {
luai_lu_byte x = (luai_lu_byte)y;
luai_DumpVar(x, D);
}
static void luai_DumpInt (int x, luai_DumpState *D) {
luai_DumpVar(x, D);
}
static void luai_DumpNumber (lua_Number x, luai_DumpState *D) {
luai_DumpVar(x, D);
}
static void luai_DumpInteger (lua_Integer x, luai_DumpState *D) {
luai_DumpVar(x, D);
}
static void luai_DumpString (const luai_TString *s, luai_DumpState *D) {
if (s == NULL)
luai_DumpByte(0, D);
else {
size_t size = luai_tsslen(s) + 1; /* include trailing '\0' */
const char *str = luai_getstr(s);
if (size < 0xFF)
luai_DumpByte(luai_cast_int(size), D);
else {
luai_DumpByte(0xFF, D);
luai_DumpVar(size, D);
}
luai_DumpVector(str, size - 1, D); /* no need to luai_save '\0' */
}
}
static void luai_DumpCode (const luai_Proto *f, luai_DumpState *D) {
luai_DumpInt(f->sizecode, D);
luai_DumpVector(f->code, f->sizecode, D);
}
static void luai_DumpFunction(const luai_Proto *f, luai_TString *psource, luai_DumpState *D);
static void luai_DumpConstants (const luai_Proto *f, luai_DumpState *D) {
int i;
int n = f->sizek;
luai_DumpInt(n, D);
for (i = 0; i < n; i++) {
const luai_TValue *o = &f->k[i];
luai_DumpByte(luai_ttype(o), D);
switch (luai_ttype(o)) {
case LUA_TNIL:
break;
case LUA_TBOOLEAN:
luai_DumpByte(luai_bvalue(o), D);
break;
case LUA_TNUMFLT:
luai_DumpNumber(luai_fltvalue(o), D);
break;
case LUA_TNUMINT:
luai_DumpInteger(luai_ivalue(o), D);
break;
case LUA_TSHRSTR:
case LUA_TLNGSTR:
luai_DumpString(luai_tsvalue(o), D);
break;
default:
lua_assert(0);
}
}
}
static void luai_DumpProtos (const luai_Proto *f, luai_DumpState *D) {
int i;
int n = f->sizep;
luai_DumpInt(n, D);
for (i = 0; i < n; i++)
luai_DumpFunction(f->p[i], f->source, D);
}
static void luai_DumpUpvalues (const luai_Proto *f, luai_DumpState *D) {
int i, n = f->sizeupvalues;
luai_DumpInt(n, D);
for (i = 0; i < n; i++) {
luai_DumpByte(f->upvalues[i].instack, D);
luai_DumpByte(f->upvalues[i].idx, D);
}
}
static void luai_DumpDebug (const luai_Proto *f, luai_DumpState *D) {
int i, n;
n = (D->strip) ? 0 : f->sizelineinfo;
luai_DumpInt(n, D);
luai_DumpVector(f->lineinfo, n, D);
n = (D->strip) ? 0 : f->sizelocvars;
luai_DumpInt(n, D);
for (i = 0; i < n; i++) {
luai_DumpString(f->locvars[i].varname, D);
luai_DumpInt(f->locvars[i].startpc, D);
luai_DumpInt(f->locvars[i].endpc, D);
}
n = (D->strip) ? 0 : f->sizeupvalues;
luai_DumpInt(n, D);
for (i = 0; i < n; i++)
luai_DumpString(f->upvalues[i].name, D);
}
static void luai_DumpFunction (const luai_Proto *f, luai_TString *psource, luai_DumpState *D) {
if (D->strip || f->source == psource)
luai_DumpString(NULL, D); /* no debug info or same source as its parent */
else
luai_DumpString(f->source, D);
luai_DumpInt(f->linedefined, D);
luai_DumpInt(f->lastlinedefined, D);
luai_DumpByte(f->numparams, D);
luai_DumpByte(f->is_vararg, D);
luai_DumpByte(f->maxstacksize, D);
luai_DumpCode(f, D);
luai_DumpConstants(f, D);
luai_DumpUpvalues(f, D);
luai_DumpProtos(f, D);
luai_DumpDebug(f, D);
}
static void luai_DumpHeader (luai_DumpState *D) {
luai_DumpLiteral(LUA_SIGNATURE, D);
luai_DumpByte(LUAC_VERSION, D);
luai_DumpByte(LUAC_FORMAT, D);
luai_DumpLiteral(LUAC_DATA, D);
luai_DumpByte(sizeof(int), D);
luai_DumpByte(sizeof(size_t), D);
luai_DumpByte(sizeof(Instruction), D);
luai_DumpByte(sizeof(lua_Integer), D);
luai_DumpByte(sizeof(lua_Number), D);
luai_DumpInteger(LUAC_INT, D);
luai_DumpNumber(LUAC_NUM, D);
}
/*
** dump Lua function as precompiled chunk
*/
int luaU_dump(lua_State *L, const luai_Proto *f, lua_Writer w, void *data,
int strip) {
luai_DumpState D;
D.L = L;
D.luai_writer = w;
D.data = data;
D.strip = strip;
D.status = 0;
luai_DumpHeader(&D);
luai_DumpByte(f->sizeupvalues, &D);
luai_DumpFunction(f, NULL, &D);
return D.status;
}
/*__lfunc.c__*/
luai_CClosure *luaF_newCclosure (lua_State *L, int n) {
LUAI_GCObject *o = luaC_newobj(L, LUA_TCCL, luai_sizeCclosure(n));
luai_CClosure *c = luai_gco2ccl(o);
c->nupvalues = luai_cast_byte(n);
return c;
}
luai_LClosure *luaF_newLclosure (lua_State *L, int n) {
LUAI_GCObject *o = luaC_newobj(L, LUA_TLCL, luai_sizeLclosure(n));
luai_LClosure *c = luai_gco2lcl(o);
c->p = NULL;
c->nupvalues = luai_cast_byte(n);
while (n--) c->upvals[n] = NULL;
return c;
}
/*
** fill a closure with new closed upvalues
*/
void luaF_initupvals (lua_State *L, luai_LClosure *cl) {
int i;
for (i = 0; i < cl->nupvalues; i++) {
luai_UpVal *uv = luaM_new(L, luai_UpVal);
uv->refcount = 1;
uv->v = &uv->u.value; /* make it closed */
luai_setnilvalue(uv->v);
cl->upvals[i] = uv;
}
}
luai_UpVal *luaF_findupval (lua_State *L, luai_StkId level) {
luai_UpVal **pp = &L->openupval;
luai_UpVal *p;
luai_UpVal *uv;
lua_assert(luai_isintwups(L) || L->openupval == NULL);
while (*pp != NULL && (p = *pp)->v >= level) {
lua_assert(luai_upisopen(p));
if (p->v == level) /* found a corresponding upvalue? */
return p; /* return it */
pp = &p->u.open.luai_next;
}
/* not found: create a new upvalue */
uv = luaM_new(L, luai_UpVal);
uv->refcount = 0;
uv->u.open.luai_next = *pp; /* link it to list of open upvalues */
uv->u.open.touched = 1;
*pp = uv;
uv->v = level; /* current value lives in the stack */
if (!luai_isintwups(L)) { /* thread not in list of threads with upvalues? */
L->twups = LUAI_G(L)->twups; /* link it to the list */
LUAI_G(L)->twups = L;
}
return uv;
}
void luaF_close (lua_State *L, luai_StkId level) {
luai_UpVal *uv;
while (L->openupval != NULL && (uv = L->openupval)->v >= level) {
lua_assert(luai_upisopen(uv));
L->openupval = uv->u.open.luai_next; /* remove from 'open' list */
if (uv->refcount == 0) /* no references? */
luaM_free(L, uv); /* free upvalue */
else {
luai_setobj(L, &uv->u.value, uv->v); /* move value to upvalue slot */
uv->v = &uv->u.value; /* now current value lives here */
luaC_upvalbarrier(L, uv);
}
}
}
luai_Proto *luaF_newproto (lua_State *L) {
LUAI_GCObject *o = luaC_newobj(L, LUA_TPROTO, sizeof(luai_Proto));
luai_Proto *f = luai_gco2p(o);
f->k = NULL;
f->sizek = 0;
f->p = NULL;
f->sizep = 0;
f->code = NULL;
f->cache = NULL;
f->sizecode = 0;
f->lineinfo = NULL;
f->sizelineinfo = 0;
f->upvalues = NULL;
f->sizeupvalues = 0;
f->numparams = 0;
f->is_vararg = 0;
f->maxstacksize = 0;
f->locvars = NULL;
f->sizelocvars = 0;
f->linedefined = 0;
f->lastlinedefined = 0;
f->source = NULL;
return f;
}
void luaF_freeproto (lua_State *L, luai_Proto *f) {
luaM_freearray(L, f->code, f->sizecode);
luaM_freearray(L, f->p, f->sizep);
luaM_freearray(L, f->k, f->sizek);
luaM_freearray(L, f->lineinfo, f->sizelineinfo);
luaM_freearray(L, f->locvars, f->sizelocvars);
luaM_freearray(L, f->upvalues, f->sizeupvalues);
luaM_free(L, f);
}
/*
** Look for n-th local variable at line 'line' in function 'func'.
** Returns NULL if not found.
*/
const char *luaF_getlocalname (const luai_Proto *f, int local_number, int pc) {
int i;
for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
if (pc < f->locvars[i].endpc) { /* is variable active? */
local_number--;
if (local_number == 0)
return luai_getstr(f->locvars[i].varname);
}
}
return NULL; /* not found */
}
/*__lgc.c__*/
/*
** internal state for collector while inside the luai_atomic phase. The
** collector should never be in this state while running regular code.
*/
#define LUAI_GCSinsideatomic (LUAI_GCSpause + 1)
/*
** cost of sweeping one element (the size of a small object divided
** by some adjust for the sweep speed)
*/
#define LUAI_GCSWEEPCOST ((sizeof(luai_TString) + 4) / 4)
/* maximum number of elements to sweep in each single step */
#define LUAI_GCSWEEPMAX (luai_cast_int((LUA_GCSTEPSIZE / LUAI_GCSWEEPCOST) / 4))
/* cost of calling one finalizer */
#define LUAI_GCFINALIZECOST LUAI_GCSWEEPCOST
/*
** macro to adjust 'stepmul': 'stepmul' is actually used like
** 'stepmul / LUAI_STEPMULADJ' (value chosen by tests)
*/
#define LUAI_STEPMULADJ 200
/*
** macro to adjust 'pause': 'pause' is actually used like
** 'pause / LUAI_PAUSEADJ' (value chosen by tests)
*/
#define LUAI_PAUSEADJ 100
/*
** 'luai_makewhite' erases all color bits then sets only the current white
** bit
*/
#define luai_maskcolors (~(luai_bitmask(LUAI_BLACKBIT) | LUAI_WHITEBITS))
#define luai_makewhite(g,x) \
(x->marked = luai_cast_byte((x->marked & luai_maskcolors) | luaC_white(g)))
#define luai_white2gray(x) luai_resetbits(x->marked, LUAI_WHITEBITS)
#define luai_black2gray(x) luai_resetbit(x->marked, LUAI_BLACKBIT)
#define luai_valiswhite(x) (luai_iscollectable(x) && luai_iswhite(luai_gcvalue(x)))
#define luai_checkdeadkey(n) lua_assert(!luai_ttisdeadkey(luai_gkey(n)) || luai_ttisnil(luai_gval(n)))
#define luai_checkconsistency(obj) \
lua_longassert(!luai_iscollectable(obj) || luai_righttt(obj))
#define luai_markvalue(g,o) { luai_checkconsistency(o); \
if (luai_valiswhite(o)) luai_reallymarkobject(g,luai_gcvalue(o)); }
#define luai_markobject(g,t) { if (luai_iswhite(t)) luai_reallymarkobject(g, luai_obj2gco(t)); }
/*
** mark an object that can be NULL (either because it is really optional,
** or it was stripped as debug info, or inside an uncompleted structure)
*/
#define luai_markobjectN(g,t) { if (t) luai_markobject(g,t); }
static void luai_reallymarkobject (luai_global_State *g, LUAI_GCObject *o);
/*
** {======================================================
** Generic functions
** =======================================================
*/
/*
** one after last element in a hash array
*/
#define luai_gnodelast(h) luai_gnode(h, luai_cast(size_t, luai_sizenode(h)))
/*
** link collectable object 'o' into list pointed by 'p'
*/
#define luai_linkgclist(o,p) ((o)->gclist = (p), (p) = luai_obj2gco(o))
/*
** If key is not marked, mark its entry as dead. This allows key to be
** collected, but keeps its entry in the table. A dead node is needed
** when Lua looks up for a key (it may be part of a chain) and when
** traversing a weak table (key might be removed from the table during
** traversal). Other places never manipulate dead keys, because its
** associated nil value is enough to signal that the entry is logically
** empty.
*/
static void luai_removeentry (luai_Node *n) {
lua_assert(luai_ttisnil(luai_gval(n)));
if (luai_valiswhite(luai_gkey(n)))
luai_setdeadvalue(luai_wgkey(n)); /* unused and unmarked key; remove it */
}
/*
** tells whether a key or value can be cleared from a weak
** table. Non-collectable objects are never removed from weak
** tables. Strings behave as 'values', so are never removed too. for
** other objects: if really collected, cannot keep them; for objects
** being finalized, keep them in keys, but not in values
*/
static int luai_iscleared (luai_global_State *g, const luai_TValue *o) {
if (!luai_iscollectable(o)) return 0;
else if (luai_ttisstring(o)) {
luai_markobject(g, luai_tsvalue(o)); /* strings are 'values', so are never weak */
return 0;
}
else return luai_iswhite(luai_gcvalue(o));
}
/*
** barrier that moves collector forward, that is, mark the white object
** being pointed by a black object. (If in sweep phase, clear the black
** object to white [sweep it] to avoid other barrier calls for this
** same object.)
*/
void luaC_barrier_ (lua_State *L, LUAI_GCObject *o, LUAI_GCObject *v) {
luai_global_State *g = LUAI_G(L);
lua_assert(luai_isblack(o) && luai_iswhite(v) && !luai_isdead(g, v) && !luai_isdead(g, o));
if (luai_keepinvariant(g)) /* must keep invariant? */
luai_reallymarkobject(g, v); /* restore invariant */
else { /* sweep phase */
lua_assert(luai_issweepphase(g));
luai_makewhite(g, o); /* mark main obj. as white to avoid other barriers */
}
}
/*
** barrier that moves collector backward, that is, mark the black object
** pointing to a white object as gray again.
*/
void luaC_barrierback_ (lua_State *L, luai_Table *t) {
luai_global_State *g = LUAI_G(L);
lua_assert(luai_isblack(t) && !luai_isdead(g, t));
luai_black2gray(t); /* make table gray (again) */
luai_linkgclist(t, g->grayagain);
}
/*
** barrier for assignments to closed upvalues. Because upvalues are
** shared among closures, it is impossible to know the color of all
** closures pointing to it. So, we assume that the object being assigned
** must be marked.
*/
void luaC_upvalbarrier_ (lua_State *L, luai_UpVal *uv) {
luai_global_State *g = LUAI_G(L);
LUAI_GCObject *o = luai_gcvalue(uv->v);
lua_assert(!luai_upisopen(uv)); /* ensured by macro luaC_upvalbarrier */
if (luai_keepinvariant(g))
luai_markobject(g, o);
}
void luaC_fix (lua_State *L, LUAI_GCObject *o) {
luai_global_State *g = LUAI_G(L);
lua_assert(g->allgc == o); /* object must be 1st in 'allgc' list! */
luai_white2gray(o); /* they will be gray forever */
g->allgc = o->luai_next; /* remove object from 'allgc' list */
o->luai_next = g->fixedgc; /* link it to 'fixedgc' list */
g->fixedgc = o;
}
/*
** create a new collectable object (with given type and size) and link
** it to 'allgc' list.
*/
LUAI_GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) {
luai_global_State *g = LUAI_G(L);
LUAI_GCObject *o = luai_cast(LUAI_GCObject *, luaM_newobject(L, luai_novariant(tt), sz));
o->marked = luaC_white(g);
o->tt = tt;
o->luai_next = g->allgc;
g->allgc = o;
return o;
}
/* }====================================================== */
/*
** {======================================================
** Mark functions
** =======================================================
*/
/*
** mark an object. Userdata, strings, and closed upvalues are visited
** and turned black here. Other objects are marked gray and added
** to appropriate list to be visited (and turned black) later. (Open
** upvalues are already linked in 'headuv' list.)
*/
static void luai_reallymarkobject (luai_global_State *g, LUAI_GCObject *o) {
reentry:
luai_white2gray(o);
switch (o->tt) {
case LUA_TSHRSTR: {
luai_gray2black(o);
g->LUAI_GCmemtrav += luai_sizelstring(luai_gco2ts(o)->shrlen);
break;
}
case LUA_TLNGSTR: {
luai_gray2black(o);
g->LUAI_GCmemtrav += luai_sizelstring(luai_gco2ts(o)->u.lnglen);
break;
}
case LUA_TUSERDATA: {
luai_TValue luai_uvalue;
luai_markobjectN(g, luai_gco2u(o)->metatable); /* mark its metatable */
luai_gray2black(o);
g->LUAI_GCmemtrav += luai_sizeudata(luai_gco2u(o));
luai_getuservalue(g->mainthread, luai_gco2u(o), &luai_uvalue);
if (luai_valiswhite(&luai_uvalue)) { /* luai_markvalue(g, &luai_uvalue); */
o = luai_gcvalue(&luai_uvalue);
goto reentry;
}
break;
}
case LUA_TLCL: {
luai_linkgclist(luai_gco2lcl(o), g->gray);
break;
}
case LUA_TCCL: {
luai_linkgclist(luai_gco2ccl(o), g->gray);
break;
}
case LUA_TTABLE: {
luai_linkgclist(luai_gco2t(o), g->gray);
break;
}
case LUA_TTHREAD: {
luai_linkgclist(luai_gco2th(o), g->gray);
break;
}
case LUA_TPROTO: {
luai_linkgclist(luai_gco2p(o), g->gray);
break;
}
default: lua_assert(0); break;
}
}
/*
** mark metamethods for basic types
*/
static void luai_markmt (luai_global_State *g) {
int i;
for (i=0; i < LUA_NUMTAGS; i++)
luai_markobjectN(g, g->mt[i]);
}
/*
** mark all objects in list of being-finalized
*/
static void luai_markbeingfnz (luai_global_State *g) {
LUAI_GCObject *o;
for (o = g->tobefnz; o != NULL; o = o->luai_next)
luai_markobject(g, o);
}
/*
** Mark all values stored in marked open upvalues from non-marked threads.
** (Values from marked threads were already marked when traversing the
** thread.) Remove from the list threads that no longer have upvalues and
** not-marked threads.
*/
static void luai_remarkupvals (luai_global_State *g) {
lua_State *thread;
lua_State **p = &g->twups;
while ((thread = *p) != NULL) {
lua_assert(!luai_isblack(thread)); /* threads are never black */
if (luai_isgray(thread) && thread->openupval != NULL)
p = &thread->twups; /* keep marked thread with upvalues in the list */
else { /* thread is not marked or without upvalues */
luai_UpVal *uv;
*p = thread->twups; /* remove thread from the list */
thread->twups = thread; /* mark that it is out of list */
for (uv = thread->openupval; uv != NULL; uv = uv->u.open.luai_next) {
if (uv->u.open.touched) {
luai_markvalue(g, uv->v); /* remark upvalue's value */
uv->u.open.touched = 0;
}
}
}
}
}
/*
** mark root set and reset all gray lists, to start a new collection
*/
static void luai_restartcollection (luai_global_State *g) {
g->gray = g->grayagain = NULL;
g->weak = g->allweak = g->ephemeron = NULL;
luai_markobject(g, g->mainthread);
luai_markvalue(g, &g->luai_l_registry);
luai_markmt(g);
luai_markbeingfnz(g); /* mark any finalizing object left from previous cycle */
}
/* }====================================================== */
/*
** {======================================================
** Traverse functions
** =======================================================
*/
/*
** Traverse a table with weak values and link it to proper list. During
** propagate phase, keep it in 'grayagain' list, to be revisited in the
** luai_atomic phase. In the luai_atomic phase, if table has any white value,
** put it in 'weak' list, to be cleared.
*/
static void luai_traverseweakvalue (luai_global_State *g, luai_Table *h) {
luai_Node *n, *limit = luai_gnodelast(h);
/* if there is array part, assume it may have white values (it is not
worth traversing it now just to luai_check) */
int hasclears = (h->sizearray > 0);
for (n = luai_gnode(h, 0); n < limit; n++) { /* traverse hash part */
luai_checkdeadkey(n);
if (luai_ttisnil(luai_gval(n))) /* entry is empty? */
luai_removeentry(n); /* remove it */
else {
lua_assert(!luai_ttisnil(luai_gkey(n)));
luai_markvalue(g, luai_gkey(n)); /* mark key */
if (!hasclears && luai_iscleared(g, luai_gval(n))) /* is there a white value? */
hasclears = 1; /* table will have to be cleared */
}
}
if (g->gcstate == LUAI_GCSpropagate)
luai_linkgclist(h, g->grayagain); /* must retraverse it in luai_atomic phase */
else if (hasclears)
luai_linkgclist(h, g->weak); /* has to be cleared later */
}
/*
** Traverse an ephemeron table and link it to proper list. Returns true
** iff any object was marked during this traversal (which implies that
** convergence has to continue). During propagation phase, keep table
** in 'grayagain' list, to be visited again in the luai_atomic phase. In
** the luai_atomic phase, if table has any white->white entry, it has to
** be revisited during ephemeron convergence (as that key may turn
** black). Otherwise, if it has any white key, table has to be cleared
** (in the luai_atomic phase).
*/
static int luai_traverseephemeron (luai_global_State *g, luai_Table *h) {
int marked = 0; /* true if an object is marked in this traversal */
int hasclears = 0; /* true if table has white keys */
int hasww = 0; /* true if table has entry "white-key -> white-value" */
luai_Node *n, *limit = luai_gnodelast(h);
unsigned int i;
/* traverse array part */
for (i = 0; i < h->sizearray; i++) {
if (luai_valiswhite(&h->array[i])) {
marked = 1;
luai_reallymarkobject(g, luai_gcvalue(&h->array[i]));
}
}
/* traverse hash part */
for (n = luai_gnode(h, 0); n < limit; n++) {
luai_checkdeadkey(n);
if (luai_ttisnil(luai_gval(n))) /* entry is empty? */
luai_removeentry(n); /* remove it */
else if (luai_iscleared(g, luai_gkey(n))) { /* key is not marked (yet)? */
hasclears = 1; /* table must be cleared */
if (luai_valiswhite(luai_gval(n))) /* value not marked yet? */
hasww = 1; /* white-white entry */
}
else if (luai_valiswhite(luai_gval(n))) { /* value not marked yet? */
marked = 1;
luai_reallymarkobject(g, luai_gcvalue(luai_gval(n))); /* mark it now */
}
}
/* link table into proper list */
if (g->gcstate == LUAI_GCSpropagate)
luai_linkgclist(h, g->grayagain); /* must retraverse it in luai_atomic phase */
else if (hasww) /* table has white->white entries? */
luai_linkgclist(h, g->ephemeron); /* have to propagate again */
else if (hasclears) /* table has white keys? */
luai_linkgclist(h, g->allweak); /* may have to clean white keys */
return marked;
}
static void luai_traversestrongtable (luai_global_State *g, luai_Table *h) {
luai_Node *n, *limit = luai_gnodelast(h);
unsigned int i;
for (i = 0; i < h->sizearray; i++) /* traverse array part */
luai_markvalue(g, &h->array[i]);
for (n = luai_gnode(h, 0); n < limit; n++) { /* traverse hash part */
luai_checkdeadkey(n);
if (luai_ttisnil(luai_gval(n))) /* entry is empty? */
luai_removeentry(n); /* remove it */
else {
lua_assert(!luai_ttisnil(luai_gkey(n)));
luai_markvalue(g, luai_gkey(n)); /* mark key */
luai_markvalue(g, luai_gval(n)); /* mark value */
}
}
}
static luai_lu_mem luai_traversetable (luai_global_State *g, luai_Table *h) {
const char *weakkey, *weakvalue;
const luai_TValue *mode = luai_gfasttm(g, h->metatable, LUAI_TM_MODE);
luai_markobjectN(g, h->metatable);
if (mode && luai_ttisstring(mode) && /* is there a weak mode? */
((weakkey = strchr(luai_svalue(mode), 'k')),
(weakvalue = strchr(luai_svalue(mode), 'v')),
(weakkey || weakvalue))) { /* is really weak? */
luai_black2gray(h); /* keep table gray */
if (!weakkey) /* strong keys? */
luai_traverseweakvalue(g, h);
else if (!weakvalue) /* strong values? */
luai_traverseephemeron(g, h);
else /* all weak */
luai_linkgclist(h, g->allweak); /* nothing to traverse now */
}
else /* not weak */
luai_traversestrongtable(g, h);
return sizeof(luai_Table) + sizeof(luai_TValue) * h->sizearray +
sizeof(luai_Node) * luai_cast(size_t, luai_allocsizenode(h));
}
/*
** Traverse a prototype. (While a prototype is being build, its
** arrays can be larger than needed; the extra slots are filled with
** NULL, so the use of 'luai_markobjectN')
*/
static int luai_traverseproto (luai_global_State *g, luai_Proto *f) {
int i;
if (f->cache && luai_iswhite(f->cache))
f->cache = NULL; /* allow cache to be collected */
luai_markobjectN(g, f->source);
for (i = 0; i < f->sizek; i++) /* mark literals */
luai_markvalue(g, &f->k[i]);
for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */
luai_markobjectN(g, f->upvalues[i].name);
for (i = 0; i < f->sizep; i++) /* mark nested protos */
luai_markobjectN(g, f->p[i]);
for (i = 0; i < f->sizelocvars; i++) /* mark local-variable names */
luai_markobjectN(g, f->locvars[i].varname);
return sizeof(luai_Proto) + sizeof(Instruction) * f->sizecode +
sizeof(luai_Proto *) * f->sizep +
sizeof(luai_TValue) * f->sizek +
sizeof(int) * f->sizelineinfo +
sizeof(luai_LocVar) * f->sizelocvars +
sizeof(luai_Upvaldesc) * f->sizeupvalues;
}
static luai_lu_mem luai_traverseCclosure (luai_global_State *g, luai_CClosure *cl) {
int i;
for (i = 0; i < cl->nupvalues; i++) /* mark its upvalues */
luai_markvalue(g, &cl->upvalue[i]);
return luai_sizeCclosure(cl->nupvalues);
}
/*
** open upvalues point to values in a thread, so those values should
** be marked when the thread is traversed except in the luai_atomic phase
** (because then the value cannot be changed by the thread and the
** thread may not be traversed again)
*/
static luai_lu_mem luai_traverseLclosure (luai_global_State *g, luai_LClosure *cl) {
int i;
luai_markobjectN(g, cl->p); /* mark its prototype */
for (i = 0; i < cl->nupvalues; i++) { /* mark its upvalues */
luai_UpVal *uv = cl->upvals[i];
if (uv != NULL) {
if (luai_upisopen(uv) && g->gcstate != LUAI_GCSinsideatomic)
uv->u.open.touched = 1; /* can be marked in 'luai_remarkupvals' */
else
luai_markvalue(g, uv->v);
}
}
return luai_sizeLclosure(cl->nupvalues);
}
static luai_lu_mem luai_traversethread (luai_global_State *g, lua_State *th) {
luai_StkId o = th->stack;
if (o == NULL)
return 1; /* stack not completely built yet */
lua_assert(g->gcstate == LUAI_GCSinsideatomic ||
th->openupval == NULL || luai_isintwups(th));
for (; o < th->top; o++) /* mark live elements in the stack */
luai_markvalue(g, o);
if (g->gcstate == LUAI_GCSinsideatomic) { /* final traversal? */
luai_StkId lim = th->stack + th->stacksize; /* real end of stack */
for (; o < lim; o++) /* clear not-marked stack slice */
luai_setnilvalue(o);
/* 'luai_remarkupvals' may have removed thread from 'twups' list */
if (!luai_isintwups(th) && th->openupval != NULL) {
th->twups = g->twups; /* link it back to the list */
g->twups = th;
}
}
else if (g->gckind != LUAI_KGC_EMERGENCY)
luaD_shrinkstack(th); /* do not change stack in emergency cycle */
return (sizeof(lua_State) + sizeof(luai_TValue) * th->stacksize +
sizeof(luai_CallInfo) * th->nci);
}
/*
** traverse one gray object, turning it to black (except for threads,
** which are always gray).
*/
static void luai_propagatemark (luai_global_State *g) {
luai_lu_mem size;
LUAI_GCObject *o = g->gray;
lua_assert(luai_isgray(o));
luai_gray2black(o);
switch (o->tt) {
case LUA_TTABLE: {
luai_Table *h = luai_gco2t(o);
g->gray = h->gclist; /* remove from 'gray' list */
size = luai_traversetable(g, h);
break;
}
case LUA_TLCL: {
luai_LClosure *cl = luai_gco2lcl(o);
g->gray = cl->gclist; /* remove from 'gray' list */
size = luai_traverseLclosure(g, cl);
break;
}
case LUA_TCCL: {
luai_CClosure *cl = luai_gco2ccl(o);
g->gray = cl->gclist; /* remove from 'gray' list */
size = luai_traverseCclosure(g, cl);
break;
}
case LUA_TTHREAD: {
lua_State *th = luai_gco2th(o);
g->gray = th->gclist; /* remove from 'gray' list */
luai_linkgclist(th, g->grayagain); /* insert into 'grayagain' list */
luai_black2gray(o);
size = luai_traversethread(g, th);
break;
}
case LUA_TPROTO: {
luai_Proto *p = luai_gco2p(o);
g->gray = p->gclist; /* remove from 'gray' list */
size = luai_traverseproto(g, p);
break;
}
default: lua_assert(0); return;
}
g->LUAI_GCmemtrav += size;
}
static void luai_propagateall (luai_global_State *g) {
while (g->gray) luai_propagatemark(g);
}
static void luai_convergeephemerons (luai_global_State *g) {
int changed;
do {
LUAI_GCObject *w;
LUAI_GCObject *luai_next = g->ephemeron; /* get ephemeron list */
g->ephemeron = NULL; /* tables may return to this list when traversed */
changed = 0;
while ((w = luai_next) != NULL) {
luai_next = luai_gco2t(w)->gclist;
if (luai_traverseephemeron(g, luai_gco2t(w))) { /* traverse marked some value? */
luai_propagateall(g); /* propagate changes */
changed = 1; /* will have to revisit all ephemeron tables */
}
}
} while (changed);
}
/* }====================================================== */
/*
** {======================================================
** Sweep Functions
** =======================================================
*/
/*
** clear entries with unmarked keys from all weaktables in list 'l' up
** to element 'f'
*/
static void luai_clearkeys (luai_global_State *g, LUAI_GCObject *l, LUAI_GCObject *f) {
for (; l != f; l = luai_gco2t(l)->gclist) {
luai_Table *h = luai_gco2t(l);
luai_Node *n, *limit = luai_gnodelast(h);
for (n = luai_gnode(h, 0); n < limit; n++) {
if (!luai_ttisnil(luai_gval(n)) && (luai_iscleared(g, luai_gkey(n)))) {
luai_setnilvalue(luai_gval(n)); /* remove value ... */
luai_removeentry(n); /* and remove entry from table */
}
}
}
}
/*
** clear entries with unmarked values from all weaktables in list 'l' up
** to element 'f'
*/
static void luai_clearvalues (luai_global_State *g, LUAI_GCObject *l, LUAI_GCObject *f) {
for (; l != f; l = luai_gco2t(l)->gclist) {
luai_Table *h = luai_gco2t(l);
luai_Node *n, *limit = luai_gnodelast(h);
unsigned int i;
for (i = 0; i < h->sizearray; i++) {
luai_TValue *o = &h->array[i];
if (luai_iscleared(g, o)) /* value was collected? */
luai_setnilvalue(o); /* remove value */
}
for (n = luai_gnode(h, 0); n < limit; n++) {
if (!luai_ttisnil(luai_gval(n)) && luai_iscleared(g, luai_gval(n))) {
luai_setnilvalue(luai_gval(n)); /* remove value ... */
luai_removeentry(n); /* and remove entry from table */
}
}
}
}
void luaC_upvdeccount (lua_State *L, luai_UpVal *uv) {
lua_assert(uv->refcount > 0);
uv->refcount--;
if (uv->refcount == 0 && !luai_upisopen(uv))
luaM_free(L, uv);
}
static void luai_freeLclosure (lua_State *L, luai_LClosure *cl) {
int i;
for (i = 0; i < cl->nupvalues; i++) {
luai_UpVal *uv = cl->upvals[i];
if (uv)
luaC_upvdeccount(L, uv);
}
luaM_freemem(L, cl, luai_sizeLclosure(cl->nupvalues));
}
static void luai_freeobj (lua_State *L, LUAI_GCObject *o) {
switch (o->tt) {
case LUA_TPROTO: luaF_freeproto(L, luai_gco2p(o)); break;
case LUA_TLCL: {
luai_freeLclosure(L, luai_gco2lcl(o));
break;
}
case LUA_TCCL: {
luaM_freemem(L, o, luai_sizeCclosure(luai_gco2ccl(o)->nupvalues));
break;
}
case LUA_TTABLE: luaH_free(L, luai_gco2t(o)); break;
case LUA_TTHREAD: luaE_freethread(L, luai_gco2th(o)); break;
case LUA_TUSERDATA: luaM_freemem(L, o, luai_sizeudata(luai_gco2u(o))); break;
case LUA_TSHRSTR:
luaS_remove(L, luai_gco2ts(o)); /* remove it from hash table */
luaM_freemem(L, o, luai_sizelstring(luai_gco2ts(o)->shrlen));
break;
case LUA_TLNGSTR: {
luaM_freemem(L, o, luai_sizelstring(luai_gco2ts(o)->u.lnglen));
break;
}
default: lua_assert(0);
}
}
#define luai_sweepwholelist(L,p) luai_sweeplist(L,p,LUAI_MAX_LUMEM)
static LUAI_GCObject **luai_sweeplist (lua_State *L, LUAI_GCObject **p, luai_lu_mem count);
/*
** sweep at most 'count' elements from a list of LUAI_GCObjects erasing dead
** objects, where a dead object is one marked with the old (non current)
** white; change all non-dead objects back to white, preparing for luai_next
** collection cycle. Return where to continue the traversal or NULL if
** list is finished.
*/
static LUAI_GCObject **luai_sweeplist (lua_State *L, LUAI_GCObject **p, luai_lu_mem count) {
luai_global_State *g = LUAI_G(L);
int ow = luai_otherwhite(g);
int white = luaC_white(g); /* current white */
while (*p != NULL && count-- > 0) {
LUAI_GCObject *curr = *p;
int marked = curr->marked;
if (luai_isdeadm(ow, marked)) { /* is 'curr' dead? */
*p = curr->luai_next; /* remove 'curr' from list */
luai_freeobj(L, curr); /* erase 'curr' */
}
else { /* change mark to 'white' */
curr->marked = luai_cast_byte((marked & luai_maskcolors) | white);
p = &curr->luai_next; /* go to luai_next element */
}
}
return (*p == NULL) ? NULL : p;
}
/*
** sweep a list until a live object (or end of list)
*/
static LUAI_GCObject **luai_sweeptolive (lua_State *L, LUAI_GCObject **p) {
LUAI_GCObject **old = p;
do {
p = luai_sweeplist(L, p, 1);
} while (p == old);
return p;
}
/* }====================================================== */
/*
** {======================================================
** Finalization
** =======================================================
*/
/*
** If possible, shrink string table
*/
static void luai_checkSizes (lua_State *L, luai_global_State *g) {
if (g->gckind != LUAI_KGC_EMERGENCY) {
luai_l_mem olddebt = g->LUAI_GCdebt;
if (g->strt.nuse < g->strt.size / 4) /* string table too big? */
luaS_resize(L, g->strt.size / 2); /* shrink it a little */
g->LUAI_GCestimate += g->LUAI_GCdebt - olddebt; /* update estimate */
}
}
static LUAI_GCObject *luai_udata2finalize (luai_global_State *g) {
LUAI_GCObject *o = g->tobefnz; /* get first element */
lua_assert(luai_tofinalize(o));
g->tobefnz = o->luai_next; /* remove it from 'tobefnz' list */
o->luai_next = g->allgc; /* return it to 'allgc' list */
g->allgc = o;
luai_resetbit(o->marked, LUAI_FINALIZEDBIT); /* object is "normal" again */
if (luai_issweepphase(g))
luai_makewhite(g, o); /* "sweep" object */
return o;
}
static void luai_dothecall (lua_State *L, void *ud) {
LUAI_UNUSED(ud);
luaD_callnoyield(L, L->top - 2, 0);
}
static void LUAI_GCTM (lua_State *L, int propagateerrors) {
luai_global_State *g = LUAI_G(L);
const luai_TValue *tm;
luai_TValue v;
luai_setgcovalue(L, &v, luai_udata2finalize(g));
tm = luaT_gettmbyobj(L, &v, LUAI_TM_GC);
if (tm != NULL && luai_ttisfunction(tm)) { /* is there a finalizer? */
int status;
luai_lu_byte oldah = L->allowhook;
int running = g->gcrunning;
L->allowhook = 0; /* stop debug hooks during LUAI_GC metamethod */
g->gcrunning = 0; /* avoid LUAI_GC steps */
luai_setobj2s(L, L->top, tm); /* push finalizer... */
luai_setobj2s(L, L->top + 1, &v); /* ... and its argument */
L->top += 2; /* and (luai_next line) call the finalizer */
L->ci->callstatus |= LUAI_CIST_FIN; /* will run a finalizer */
status = luaD_pcall(L, luai_dothecall, NULL, luai_savestack(L, L->top - 2), 0);
L->ci->callstatus &= ~LUAI_CIST_FIN; /* not running a finalizer anymore */
L->allowhook = oldah; /* restore hooks */
g->gcrunning = running; /* restore state */
if (status != LUA_OK && propagateerrors) { /* error while running __gc? */
if (status == LUA_ERRRUN) { /* is there an error object? */
const char *msg = (luai_ttisstring(L->top - 1))
? luai_svalue(L->top - 1)
: "no message";
luaO_pushfstring(L, "error in __gc metamethod (%s)", msg);
status = LUA_ERRGCMM; /* error in __gc metamethod */
}
luaD_throw(L, status); /* re-throw error */
}
}
}
/*
** call a few (up to 'g->gcfinnum') finalizers
*/
static int luai_runafewfinalizers (lua_State *L) {
luai_global_State *g = LUAI_G(L);
unsigned int i;
lua_assert(!g->tobefnz || g->gcfinnum > 0);
for (i = 0; g->tobefnz && i < g->gcfinnum; i++)
LUAI_GCTM(L, 1); /* call one finalizer */
g->gcfinnum = (!g->tobefnz) ? 0 /* nothing more to finalize? */
: g->gcfinnum * 2; /* else call a few more luai_next time */
return i;
}
/*
** call all pending finalizers
*/
static void luai_callallpendingfinalizers (lua_State *L) {
luai_global_State *g = LUAI_G(L);
while (g->tobefnz)
LUAI_GCTM(L, 0);
}
/*
** find last 'luai_next' luai_field in list 'p' list (to add elements in its end)
*/
static LUAI_GCObject **luai_findlast (LUAI_GCObject **p) {
while (*p != NULL)
p = &(*p)->luai_next;
return p;
}
/*
** move all unreachable objects (or 'all' objects) that need
** finalization from list 'finobj' to list 'tobefnz' (to be finalized)
*/
static void luai_separatetobefnz (luai_global_State *g, int all) {
LUAI_GCObject *curr;
LUAI_GCObject **p = &g->finobj;
LUAI_GCObject **lastnext = luai_findlast(&g->tobefnz);
while ((curr = *p) != NULL) { /* traverse all finalizable objects */
lua_assert(luai_tofinalize(curr));
if (!(luai_iswhite(curr) || all)) /* not being collected? */
p = &curr->luai_next; /* don't bother with it */
else {
*p = curr->luai_next; /* remove 'curr' from 'finobj' list */
curr->luai_next = *lastnext; /* link at the end of 'tobefnz' list */
*lastnext = curr;
lastnext = &curr->luai_next;
}
}
}
/*
** if object 'o' has a finalizer, remove it from 'allgc' list (must
** search the list to find it) and link it in 'finobj' list.
*/
void luaC_checkfinalizer (lua_State *L, LUAI_GCObject *o, luai_Table *mt) {
luai_global_State *g = LUAI_G(L);
if (luai_tofinalize(o) || /* obj. is already marked... */
luai_gfasttm(g, mt, LUAI_TM_GC) == NULL) /* or has no finalizer? */
return; /* nothing to be done */
else { /* move 'o' to 'finobj' list */
LUAI_GCObject **p;
if (luai_issweepphase(g)) {
luai_makewhite(g, o); /* "sweep" object 'o' */
if (g->sweepgc == &o->luai_next) /* should not remove 'sweepgc' object */
g->sweepgc = luai_sweeptolive(L, g->sweepgc); /* change 'sweepgc' */
}
/* search for pointer pointing to 'o' */
for (p = &g->allgc; *p != o; p = &(*p)->luai_next) { /* empty */ }
*p = o->luai_next; /* remove 'o' from 'allgc' list */
o->luai_next = g->finobj; /* link it in 'finobj' list */
g->finobj = o;
luai_l_setbit(o->marked, LUAI_FINALIZEDBIT); /* mark it as such */
}
}
/* }====================================================== */
/*
** {======================================================
** LUAI_GC control
** =======================================================
*/
/*
** Set a reasonable "time" to wait before starting a new LUAI_GC cycle; cycle
** will start when memory use hits threshold. (Division by 'estimate'
** should be OK: it cannot be zero (because Lua cannot even start with
** less than LUAI_PAUSEADJ bytes).
*/
static void luai_setpause (luai_global_State *g) {
luai_l_mem threshold, debt;
luai_l_mem estimate = g->LUAI_GCestimate / LUAI_PAUSEADJ; /* adjust 'estimate' */
lua_assert(estimate > 0);
threshold = (g->gcpause < LUAI_MAX_LMEM / estimate) /* overflow? */
? estimate * g->gcpause /* no overflow */
: LUAI_MAX_LMEM; /* overflow; truncate to maximum */
debt = luai_gettotalbytes(g) - threshold;
luaE_setdebt(g, debt);
}
/*
** Enter first sweep phase.
** The call to 'luai_sweeplist' tries to make pointer point to an object
** inside the list (instead of to the header), so that the real sweep do
** not need to skip objects created between "now" and the start of the
** real sweep.
*/
static void luai_entersweep (lua_State *L) {
luai_global_State *g = LUAI_G(L);
g->gcstate = LUAI_GCSswpallgc;
lua_assert(g->sweepgc == NULL);
g->sweepgc = luai_sweeplist(L, &g->allgc, 1);
}
void luaC_freeallobjects (lua_State *L) {
luai_global_State *g = LUAI_G(L);
luai_separatetobefnz(g, 1); /* separate all objects with finalizers */
lua_assert(g->finobj == NULL);
luai_callallpendingfinalizers(L);
lua_assert(g->tobefnz == NULL);
g->currentwhite = LUAI_WHITEBITS; /* this "white" makes all objects look dead */
g->gckind = LUAI_KGC_NORMAL;
luai_sweepwholelist(L, &g->finobj);
luai_sweepwholelist(L, &g->allgc);
luai_sweepwholelist(L, &g->fixedgc); /* collect fixed objects */
lua_assert(g->strt.nuse == 0);
}
static luai_l_mem luai_atomic (lua_State *L) {
luai_global_State *g = LUAI_G(L);
luai_l_mem work;
LUAI_GCObject *origweak, *origall;
LUAI_GCObject *grayagain = g->grayagain; /* luai_save original list */
lua_assert(g->ephemeron == NULL && g->weak == NULL);
lua_assert(!luai_iswhite(g->mainthread));
g->gcstate = LUAI_GCSinsideatomic;
g->LUAI_GCmemtrav = 0; /* start counting work */
luai_markobject(g, L); /* mark running thread */
/* registry and global metatables may be changed by API */
luai_markvalue(g, &g->luai_l_registry);
luai_markmt(g); /* mark global metatables */
/* remark occasional upvalues of (maybe) dead threads */
luai_remarkupvals(g);
luai_propagateall(g); /* propagate changes */
work = g->LUAI_GCmemtrav; /* stop counting (do not recount 'grayagain') */
g->gray = grayagain;
luai_propagateall(g); /* traverse 'grayagain' list */
g->LUAI_GCmemtrav = 0; /* restart counting */
luai_convergeephemerons(g);
/* at this point, all strongly accessible objects are marked. */
/* Clear values from weak tables, before checking finalizers */
luai_clearvalues(g, g->weak, NULL);
luai_clearvalues(g, g->allweak, NULL);
origweak = g->weak; origall = g->allweak;
work += g->LUAI_GCmemtrav; /* stop counting (objects being finalized) */
luai_separatetobefnz(g, 0); /* separate objects to be finalized */
g->gcfinnum = 1; /* there may be objects to be finalized */
luai_markbeingfnz(g); /* mark objects that will be finalized */
luai_propagateall(g); /* remark, to propagate 'resurrection' */
g->LUAI_GCmemtrav = 0; /* restart counting */
luai_convergeephemerons(g);
/* at this point, all resurrected objects are marked. */
/* remove dead objects from weak tables */
luai_clearkeys(g, g->ephemeron, NULL); /* clear keys from all ephemeron tables */
luai_clearkeys(g, g->allweak, NULL); /* clear keys from all 'allweak' tables */
/* clear values from resurrected weak tables */
luai_clearvalues(g, g->weak, origweak);
luai_clearvalues(g, g->allweak, origall);
luaS_clearcache(g);
g->currentwhite = luai_cast_byte(luai_otherwhite(g)); /* flip current white */
work += g->LUAI_GCmemtrav; /* complete counting */
return work; /* estimate of memory marked by 'luai_atomic' */
}
static luai_lu_mem luai_sweepstep (lua_State *L, luai_global_State *g,
int nextstate, LUAI_GCObject **nextlist) {
if (g->sweepgc) {
luai_l_mem olddebt = g->LUAI_GCdebt;
g->sweepgc = luai_sweeplist(L, g->sweepgc, LUAI_GCSWEEPMAX);
g->LUAI_GCestimate += g->LUAI_GCdebt - olddebt; /* update estimate */
if (g->sweepgc) /* is there still something to sweep? */
return (LUAI_GCSWEEPMAX * LUAI_GCSWEEPCOST);
}
/* else enter luai_next state */
g->gcstate = nextstate;
g->sweepgc = nextlist;
return 0;
}
static luai_lu_mem luai_singlestep (lua_State *L) {
luai_global_State *g = LUAI_G(L);
switch (g->gcstate) {
case LUAI_GCSpause: {
g->LUAI_GCmemtrav = g->strt.size * sizeof(LUAI_GCObject*);
luai_restartcollection(g);
g->gcstate = LUAI_GCSpropagate;
return g->LUAI_GCmemtrav;
}
case LUAI_GCSpropagate: {
g->LUAI_GCmemtrav = 0;
lua_assert(g->gray);
luai_propagatemark(g);
if (g->gray == NULL) /* no more gray objects? */
g->gcstate = LUAI_GCSatomic; /* finish propagate phase */
return g->LUAI_GCmemtrav; /* memory traversed in this step */
}
case LUAI_GCSatomic: {
luai_lu_mem work;
luai_propagateall(g); /* make sure gray list is empty */
work = luai_atomic(L); /* work is what was traversed by 'luai_atomic' */
luai_entersweep(L);
g->LUAI_GCestimate = luai_gettotalbytes(g); /* first estimate */;
return work;
}
case LUAI_GCSswpallgc: { /* sweep "regular" objects */
return luai_sweepstep(L, g, LUAI_GCSswpfinobj, &g->finobj);
}
case LUAI_GCSswpfinobj: { /* sweep objects with finalizers */
return luai_sweepstep(L, g, LUAI_GCSswptobefnz, &g->tobefnz);
}
case LUAI_GCSswptobefnz: { /* sweep objects to be finalized */
return luai_sweepstep(L, g, LUAI_GCSswpend, NULL);
}
case LUAI_GCSswpend: { /* finish sweeps */
luai_makewhite(g, g->mainthread); /* sweep main thread */
luai_checkSizes(L, g);
g->gcstate = LUAI_GCScallfin;
return 0;
}
case LUAI_GCScallfin: { /* call remaining finalizers */
if (g->tobefnz && g->gckind != LUAI_KGC_EMERGENCY) {
int n = luai_runafewfinalizers(L);
return (n * LUAI_GCFINALIZECOST);
}
else { /* emergency mode or no more finalizers */
g->gcstate = LUAI_GCSpause; /* finish collection */
return 0;
}
}
default: lua_assert(0); return 0;
}
}
/*
** advances the garbage collector until it reaches a state allowed
** by 'statemask'
*/
void luaC_runtilstate (lua_State *L, int statesmask) {
luai_global_State *g = LUAI_G(L);
while (!luai_testbit(statesmask, g->gcstate))
luai_singlestep(L);
}
/*
** get LUAI_GC debt and convert it from Kb to 'work units' (avoid zero debt
** and overflows)
*/
static luai_l_mem luai_getdebt (luai_global_State *g) {
luai_l_mem debt = g->LUAI_GCdebt;
int stepmul = g->gcstepmul;
if (debt <= 0) return 0; /* minimal debt */
else {
debt = (debt / LUAI_STEPMULADJ) + 1;
debt = (debt < LUAI_MAX_LMEM / stepmul) ? debt * stepmul : LUAI_MAX_LMEM;
return debt;
}
}
/*
** performs a basic LUAI_GC step when collector is running
*/
void luaC_step (lua_State *L) {
luai_global_State *g = LUAI_G(L);
luai_l_mem debt = luai_getdebt(g); /* LUAI_GC deficit (be paid now) */
if (!g->gcrunning) { /* not running? */
luaE_setdebt(g, -LUA_GCSTEPSIZE * 10); /* avoid being called too often */
return;
}
do { /* repeat until pause or enough "credit" (negative debt) */
luai_lu_mem work = luai_singlestep(L); /* perform one single step */
debt -= work;
} while (debt > -LUA_GCSTEPSIZE && g->gcstate != LUAI_GCSpause);
if (g->gcstate == LUAI_GCSpause)
luai_setpause(g); /* pause until luai_next cycle */
else {
debt = (debt / g->gcstepmul) * LUAI_STEPMULADJ; /* convert 'work units' to Kb */
luaE_setdebt(g, debt);
luai_runafewfinalizers(L);
}
}
/*
** Performs a full LUAI_GC cycle; if 'isemergency', set a flag to avoid
** some operations which could change the interpreter state in some
** unexpected ways (running finalizers and shrinking some structures).
** Before running the collection, luai_check 'luai_keepinvariant'; if it is true,
** there may be some objects marked as black, so the collector has
** to sweep all objects to turn them back to white (as white has not
** changed, nothing will be collected).
*/
void luaC_fullgc (lua_State *L, int isemergency) {
luai_global_State *g = LUAI_G(L);
lua_assert(g->gckind == LUAI_KGC_NORMAL);
if (isemergency) g->gckind = LUAI_KGC_EMERGENCY; /* set flag */
if (luai_keepinvariant(g)) { /* black objects? */
luai_entersweep(L); /* sweep everything to turn them back to white */
}
/* finish any pending sweep phase to start a new cycle */
luaC_runtilstate(L, luai_bitmask(LUAI_GCSpause));
luaC_runtilstate(L, ~luai_bitmask(LUAI_GCSpause)); /* start new collection */
luaC_runtilstate(L, luai_bitmask(LUAI_GCScallfin)); /* run up to finalizers */
/* estimate must be correct after a full LUAI_GC cycle */
lua_assert(g->LUAI_GCestimate == luai_gettotalbytes(g));
luaC_runtilstate(L, luai_bitmask(LUAI_GCSpause)); /* finish collection */
g->gckind = LUAI_KGC_NORMAL;
luai_setpause(g);
}
/* }====================================================== */
/*__linit.c__*/
/*
** these libs are loaded by lua.c and are readily available to any Lua
** program
*/
static const luaL_Reg luai_loadedlibs[] = {
{"_G", luaopen_base},
{LUA_LOADLIBNAME, luaopen_package},
{LUA_COLIBNAME, luaopen_coroutine},
{LUA_TABLIBNAME, luaopen_table},
{LUA_IOLIBNAME, luaopen_io},
{LUA_OSLIBNAME, luaopen_os},
{LUA_STRLIBNAME, luaopen_string},
{LUA_MATHLIBNAME, luaopen_math},
{LUA_UTF8LIBNAME, luaopen_utf8},
{LUA_DBLIBNAME, luaopen_debug},
#if defined(LUA_COMPAT_BITLIB)
{LUA_BITLIBNAME, luaopen_bit32},
#endif
{NULL, NULL}
};
LUALIB_API void luaL_openlibs (lua_State *L) {
const luaL_Reg *lib;
/* "require" functions from 'luai_loadedlibs' and set results to global table */
for (lib = luai_loadedlibs; lib->func; lib++) {
luaL_requiref(L, lib->name, lib->func, 1);
lua_pop(L, 1); /* remove lib */
}
}
/*__liolib.c__*/
/*
** Change this macro to accept other modes for 'fopen' besides
** the standard ones.
*/
#if !defined(luai_l_checkmode)
/* accepted extensions to 'mode' in 'fopen' */
#if !defined(LUAI_L_MODEEXT)
#define LUAI_L_MODEEXT "b"
#endif
/* Check whether 'mode' matches '[rwa]%+?[LUAI_L_MODEEXT]*' */
static int luai_l_checkmode (const char *mode) {
return (*mode != '\0' && strchr("rwa", *(mode++)) != NULL &&
(*mode != '+' || (++mode, 1)) && /* skip if char is '+' */
(strspn(mode, LUAI_L_MODEEXT) == strlen(mode))); /* luai_check extensions */
}
#endif
/*
** {======================================================
** luai_l_popen spawns a new process connected to the current
** one through the file streams.
** =======================================================
*/
#if !defined(luai_l_popen) /* { */
#if defined(LUA_USE_POSIX) /* { */
#define luai_l_popen(L,c,m) (fflush(NULL), popen(c,m))
#define luai_l_pclose(L,file) (pclose(file))
#elif defined(LUA_USE_WINDOWS) /* }{ */
#define luai_l_popen(L,c,m) (_popen(c,m))
#define luai_l_pclose(L,file) (_pclose(file))
#else /* }{ */
/* ISO C definitions */
#define luai_l_popen(L,c,m) \
((void)((void)c, m), \
luaL_error(L, "'popen' not supported"), \
(FILE*)0)
#define luai_l_pclose(L,file) ((void)L, (void)file, -1)
#endif /* } */
#endif /* } */
/* }====================================================== */
#if !defined(luai_l_getc) /* { */
#if defined(LUA_USE_POSIX)
#define luai_l_getc(f) getc_unlocked(f)
#define luai_l_lockfile(f) flockfile(f)
#define luai_l_unlockfile(f) funlockfile(f)
#else
#define luai_l_getc(f) getc(f)
#define luai_l_lockfile(f) ((void)0)
#define luai_l_unlockfile(f) ((void)0)
#endif
#endif /* } */
/*
** {======================================================
** luai_l_fseek: configuration for longer offsets
** =======================================================
*/
#if !defined(luai_l_fseek) /* { */
#if defined(LUA_USE_POSIX) /* { */
#include <sys/types.h>
#define luai_l_fseek(f,o,w) fseeko(f,o,w)
#define luai_l_ftell(f) ftello(f)
#define luai_l_seeknum off_t
#elif defined(LUA_USE_WINDOWS) && !defined(_CRTIMP_TYPEINFO) \
&& defined(_MSC_VER) && (_MSC_VER >= 1400) /* }{ */
/* Windows (but not DDK) and Visual C++ 2005 or higher */
#define luai_l_fseek(f,o,w) _fseeki64(f,o,w)
#define luai_l_ftell(f) _ftelli64(f)
#define luai_l_seeknum __int64
#else /* }{ */
/* ISO C definitions */
#define luai_l_fseek(f,o,w) fseek(f,o,w)
#define luai_l_ftell(f) ftell(f)
#define luai_l_seeknum long
#endif /* } */
#endif /* } */
/* }====================================================== */
#define LUAI_IO_PREFIX "_IO_"
#define LUAI_IOPREF_LEN (sizeof(LUAI_IO_PREFIX)/sizeof(char) - 1)
#define LUAI_IO_INPUT (LUAI_IO_PREFIX "input")
#define LUAI_IO_OUTPUT (LUAI_IO_PREFIX "output")
typedef luaL_Stream luai_LStream;
#define luai_tolstream(L) ((luai_LStream *)luaL_checkudata(L, 1, LUA_FILEHANDLE))
#define luai_isclosed(p) ((p)->closef == NULL)
static int luai_io_type (lua_State *L) {
luai_LStream *p;
luaL_checkany(L, 1);
p = (luai_LStream *)luaL_testudata(L, 1, LUA_FILEHANDLE);
if (p == NULL)
lua_pushnil(L); /* not a file */
else if (luai_isclosed(p))
lua_pushliteral(L, "closed file");
else
lua_pushliteral(L, "file");
return 1;
}
static int luai_f_tostring (lua_State *L) {
luai_LStream *p = luai_tolstream(L);
if (luai_isclosed(p))
lua_pushliteral(L, "file (closed)");
else
lua_pushfstring(L, "file (%p)", p->f);
return 1;
}
static FILE *luai_tofile (lua_State *L) {
luai_LStream *p = luai_tolstream(L);
if (luai_isclosed(p))
luaL_error(L, "attempt to use a closed file");
lua_assert(p->f);
return p->f;
}
/*
** When creating file handles, always creates a 'closed' file handle
** before opening the actual file; so, if there is a memory error, the
** handle is in a consistent state.
*/
static luai_LStream *luai_toprefile (lua_State *L) {
luai_LStream *p = (luai_LStream *)lua_newuserdata(L, sizeof(luai_LStream));
p->closef = NULL; /* mark file handle as 'closed' */
luaL_setmetatable(L, LUA_FILEHANDLE);
return p;
}
/*
** Calls the 'close' function from a file handle. The 'volatile' avoids
** a bug in some versions of the Clang compiler (e.g., clang 3.0 for
** 32 bits).
*/
static int luai_aux_close (lua_State *L) {
luai_LStream *p = luai_tolstream(L);
volatile lua_CFunction cf = p->closef;
p->closef = NULL; /* mark stream as closed */
return (*cf)(L); /* close it */
}
static int luai_io_close (lua_State *L) {
if (lua_isnone(L, 1)) /* no argument? */
lua_getfield(L, LUA_REGISTRYINDEX, LUAI_IO_OUTPUT); /* use standard output */
luai_tofile(L); /* make sure argument is an open stream */
return luai_aux_close(L);
}
static int luai_f_gc (lua_State *L) {
luai_LStream *p = luai_tolstream(L);
if (!luai_isclosed(p) && p->f != NULL)
luai_aux_close(L); /* ignore closed and incompletely open files */
return 0;
}
/*
** function to close regular files
*/
static int luai_io_fclose (lua_State *L) {
luai_LStream *p = luai_tolstream(L);
int res = fclose(p->f);
return luaL_fileresult(L, (res == 0), NULL);
}
static luai_LStream *luai_newfile (lua_State *L) {
luai_LStream *p = luai_toprefile(L);
p->f = NULL;
p->closef = &luai_io_fclose;
return p;
}
static void luai_opencheck (lua_State *L, const char *fname, const char *mode) {
luai_LStream *p = luai_newfile(L);
p->f = fopen(fname, mode);
if (p->f == NULL)
luaL_error(L, "cannot open file '%s' (%s)", fname, strerror(errno));
}
static int luai_io_open (lua_State *L) {
const char *filename = luaL_checkstring(L, 1);
const char *mode = luaL_optstring(L, 2, "r");
luai_LStream *p = luai_newfile(L);
const char *md = mode; /* to traverse/luai_check mode */
luaL_argcheck(L, luai_l_checkmode(md), 2, "invalid mode");
p->f = fopen(filename, mode);
return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
}
/*
** function to close 'popen' files
*/
static int luai_io_pclose (lua_State *L) {
luai_LStream *p = luai_tolstream(L);
return luaL_execresult(L, luai_l_pclose(L, p->f));
}
static int luai_io_popen (lua_State *L) {
const char *filename = luaL_checkstring(L, 1);
const char *mode = luaL_optstring(L, 2, "r");
luai_LStream *p = luai_toprefile(L);
p->f = luai_l_popen(L, filename, mode);
p->closef = &luai_io_pclose;
return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
}
static int luai_io_tmpfile (lua_State *L) {
luai_LStream *p = luai_newfile(L);
p->f = tmpfile();
return (p->f == NULL) ? luaL_fileresult(L, 0, NULL) : 1;
}
static FILE *luai_getiofile (lua_State *L, const char *findex) {
luai_LStream *p;
lua_getfield(L, LUA_REGISTRYINDEX, findex);
p = (luai_LStream *)lua_touserdata(L, -1);
if (luai_isclosed(p))
luaL_error(L, "standard %s file is closed", findex + LUAI_IOPREF_LEN);
return p->f;
}
static int luai_g_iofile (lua_State *L, const char *f, const char *mode) {
if (!lua_isnoneornil(L, 1)) {
const char *filename = lua_tostring(L, 1);
if (filename)
luai_opencheck(L, filename, mode);
else {
luai_tofile(L); /* luai_check that it's a valid file handle */
lua_pushvalue(L, 1);
}
lua_setfield(L, LUA_REGISTRYINDEX, f);
}
/* return current value */
lua_getfield(L, LUA_REGISTRYINDEX, f);
return 1;
}
static int luai_io_input (lua_State *L) {
return luai_g_iofile(L, LUAI_IO_INPUT, "r");
}
static int luai_io_output (lua_State *L) {
return luai_g_iofile(L, LUAI_IO_OUTPUT, "w");
}
static int luai_io_readline (lua_State *L);
/*
** maximum number of arguments to 'f:lines'/'io.lines' (it + 3 must fit
** in the limit for upvalues of a closure)
*/
#define LUAI_MAXARGLINE 250
static void luai_aux_lines (lua_State *L, int toclose) {
int n = lua_gettop(L) - 1; /* number of arguments to read */
luaL_argcheck(L, n <= LUAI_MAXARGLINE, LUAI_MAXARGLINE + 2, "too many arguments");
lua_pushinteger(L, n); /* number of arguments to read */
lua_pushboolean(L, toclose); /* close/not close file when finished */
lua_rotate(L, 2, 2); /* move 'n' and 'toclose' to their positions */
lua_pushcclosure(L, luai_io_readline, 3 + n);
}
static int luai_f_lines (lua_State *L) {
luai_tofile(L); /* luai_check that it's a valid file handle */
luai_aux_lines(L, 0);
return 1;
}
static int luai_io_lines (lua_State *L) {
int toclose;
if (lua_isnone(L, 1)) lua_pushnil(L); /* at least one argument */
if (lua_isnil(L, 1)) { /* no file name? */
lua_getfield(L, LUA_REGISTRYINDEX, LUAI_IO_INPUT); /* get default input */
lua_replace(L, 1); /* put it at index 1 */
luai_tofile(L); /* luai_check that it's a valid file handle */
toclose = 0; /* do not close it after iteration */
}
else { /* open a new file */
const char *filename = luaL_checkstring(L, 1);
luai_opencheck(L, filename, "r");
lua_replace(L, 1); /* put file at index 1 */
toclose = 1; /* close it after iteration */
}
luai_aux_lines(L, toclose);
return 1;
}
/*
** {======================================================
** READ
** =======================================================
*/
/* maximum length of a numeral */
#if !defined (LUAI_L_MAXLENNUM)
#define LUAI_L_MAXLENNUM 200
#endif
/* auxiliary structure used by 'luai_read_number' */
typedef struct {
FILE *f; /* file being read */
int c; /* current character (look ahead) */
int n; /* number of elements in buffer 'buff' */
char buff[LUAI_L_MAXLENNUM + 1]; /* +1 for ending '\0' */
} luai_RN;
/*
** Add current char to buffer (if not out of space) and read luai_next one
*/
static int luai_nextc (luai_RN *rn) {
if (rn->n >= LUAI_L_MAXLENNUM) { /* buffer overflow? */
rn->buff[0] = '\0'; /* invalidate result */
return 0; /* fail */
}
else {
rn->buff[rn->n++] = rn->c; /* luai_save current char */
rn->c = luai_l_getc(rn->f); /* read luai_next one */
return 1;
}
}
/*
** Accept current char if it is in 'set' (of size 2)
*/
static int luai_test2 (luai_RN *rn, const char *set) {
if (rn->c == set[0] || rn->c == set[1])
return luai_nextc(rn);
else return 0;
}
/*
** Read a sequence of (hex)digits
*/
static int luai_readdigits (luai_RN *rn, int hex) {
int count = 0;
while ((hex ? isxdigit(rn->c) : isdigit(rn->c)) && luai_nextc(rn))
count++;
return count;
}
/*
** Read a number: first reads a valid prefix of a numeral into a buffer.
** Then it calls 'lua_stringtonumber' to luai_check whether the format is
** correct and to convert it to a Lua number
*/
static int luai_read_number (lua_State *L, FILE *f) {
luai_RN rn;
int count = 0;
int hex = 0;
char decp[2];
rn.f = f; rn.n = 0;
decp[0] = lua_getlocaledecpoint(); /* get decimal point from locale */
decp[1] = '.'; /* always accept a dot */
luai_l_lockfile(rn.f);
do { rn.c = luai_l_getc(rn.f); } while (isspace(rn.c)); /* skip spaces */
luai_test2(&rn, "-+"); /* optional signal */
if (luai_test2(&rn, "00")) {
if (luai_test2(&rn, "xX")) hex = 1; /* numeral is hexadecimal */
else count = 1; /* count initial '0' as a valid luai_digit */
}
count += luai_readdigits(&rn, hex); /* integral part */
if (luai_test2(&rn, decp)) /* decimal point? */
count += luai_readdigits(&rn, hex); /* fractional part */
if (count > 0 && luai_test2(&rn, (hex ? "pP" : "eE"))) { /* exponent mark? */
luai_test2(&rn, "-+"); /* exponent signal */
luai_readdigits(&rn, 0); /* exponent digits */
}
ungetc(rn.c, rn.f); /* unread look-ahead char */
luai_l_unlockfile(rn.f);
rn.buff[rn.n] = '\0'; /* finish string */
if (lua_stringtonumber(L, rn.buff)) /* is this a valid number? */
return 1; /* ok */
else { /* invalid format */
lua_pushnil(L); /* "result" to be removed */
return 0; /* read fails */
}
}
static int luai_test_eof (lua_State *L, FILE *f) {
int c = getc(f);
ungetc(c, f); /* no-op when c == EOF */
lua_pushliteral(L, "");
return (c != EOF);
}
static int luai_read_line (lua_State *L, FILE *f, int chop) {
luaL_Buffer b;
int c = '\0';
luaL_buffinit(L, &b);
while (c != EOF && c != '\n') { /* repeat until end of line */
char *buff = luaL_prepbuffer(&b); /* preallocate buffer */
int i = 0;
luai_l_lockfile(f); /* no memory errors can happen inside the lock */
while (i < LUAL_BUFFERSIZE && (c = luai_l_getc(f)) != EOF && c != '\n')
buff[i++] = c;
luai_l_unlockfile(f);
luaL_addsize(&b, i);
}
if (!chop && c == '\n') /* want a newline and have one? */
luaL_addchar(&b, c); /* add ending newline to result */
luaL_pushresult(&b); /* close buffer */
/* return ok if read something (either a newline or something else) */
return (c == '\n' || lua_rawlen(L, -1) > 0);
}
static void luai_read_all (lua_State *L, FILE *f) {
size_t nr;
luaL_Buffer b;
luaL_buffinit(L, &b);
do { /* read file in chunks of LUAL_BUFFERSIZE bytes */
char *p = luaL_prepbuffer(&b);
nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f);
luaL_addsize(&b, nr);
} while (nr == LUAL_BUFFERSIZE);
luaL_pushresult(&b); /* close buffer */
}
static int luai_read_chars (lua_State *L, FILE *f, size_t n) {
size_t nr; /* number of chars actually read */
char *p;
luaL_Buffer b;
luaL_buffinit(L, &b);
p = luaL_prepbuffsize(&b, n); /* prepare buffer to read whole luai_getblock */
nr = fread(p, sizeof(char), n, f); /* try to read 'n' chars */
luaL_addsize(&b, nr);
luaL_pushresult(&b); /* close buffer */
return (nr > 0); /* true iff read something */
}
static int luai_g_read (lua_State *L, FILE *f, int first) {
int nargs = lua_gettop(L) - 1;
int success;
int n;
clearerr(f);
if (nargs == 0) { /* no arguments? */
success = luai_read_line(L, f, 1);
n = first+1; /* to return 1 result */
}
else { /* ensure stack space for all results and for auxlib's buffer */
luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
success = 1;
for (n = first; nargs-- && success; n++) {
if (lua_type(L, n) == LUA_TNUMBER) {
size_t l = (size_t)luaL_checkinteger(L, n);
success = (l == 0) ? luai_test_eof(L, f) : luai_read_chars(L, f, l);
}
else {
const char *p = luaL_checkstring(L, n);
if (*p == '*') p++; /* skip optional '*' (for compatibility) */
switch (*p) {
case 'n': /* number */
success = luai_read_number(L, f);
break;
case 'l': /* line */
success = luai_read_line(L, f, 1);
break;
case 'L': /* line with end-of-line */
success = luai_read_line(L, f, 0);
break;
case 'a': /* file */
luai_read_all(L, f); /* read entire file */
success = 1; /* always success */
break;
default:
return luaL_argerror(L, n, "invalid format");
}
}
}
}
if (ferror(f))
return luaL_fileresult(L, 0, NULL);
if (!success) {
lua_pop(L, 1); /* remove last result */
lua_pushnil(L); /* push nil instead */
}
return n - first;
}
static int luai_io_read (lua_State *L) {
return luai_g_read(L, luai_getiofile(L, LUAI_IO_INPUT), 1);
}
static int luai_f_read (lua_State *L) {
return luai_g_read(L, luai_tofile(L), 2);
}
static int luai_io_readline (lua_State *L) {
luai_LStream *p = (luai_LStream *)lua_touserdata(L, lua_upvalueindex(1));
int i;
int n = (int)lua_tointeger(L, lua_upvalueindex(2));
if (luai_isclosed(p)) /* file is already closed? */
return luaL_error(L, "file is already closed");
lua_settop(L , 1);
luaL_checkstack(L, n, "too many arguments");
for (i = 1; i <= n; i++) /* push arguments to 'luai_g_read' */
lua_pushvalue(L, lua_upvalueindex(3 + i));
n = luai_g_read(L, p->f, 2); /* 'n' is number of results */
lua_assert(n > 0); /* should return at least a nil */
if (lua_toboolean(L, -n)) /* read at least one value? */
return n; /* return them */
else { /* first result is nil: EOF or error */
if (n > 1) { /* is there error information? */
/* 2nd result is error message */
return luaL_error(L, "%s", lua_tostring(L, -n + 1));
}
if (lua_toboolean(L, lua_upvalueindex(3))) { /* generator created file? */
lua_settop(L, 0);
lua_pushvalue(L, lua_upvalueindex(1));
luai_aux_close(L); /* close it */
}
return 0;
}
}
/* }====================================================== */
static int luai_g_write (lua_State *L, FILE *f, int arg) {
int nargs = lua_gettop(L) - arg;
int status = 1;
for (; nargs--; arg++) {
if (lua_type(L, arg) == LUA_TNUMBER) {
/* optimization: could be done exactly as for strings */
int len = lua_isinteger(L, arg)
? fprintf(f, LUA_INTEGER_FMT,
(LUAI_UACINT)lua_tointeger(L, arg))
: fprintf(f, LUA_NUMBER_FMT,
(LUAI_UACNUMBER)lua_tonumber(L, arg));
status = status && (len > 0);
}
else {
size_t l;
const char *s = luaL_checklstring(L, arg, &l);
status = status && (fwrite(s, sizeof(char), l, f) == l);
}
}
if (status) return 1; /* file handle already on stack top */
else return luaL_fileresult(L, status, NULL);
}
static int luai_io_write (lua_State *L) {
return luai_g_write(L, luai_getiofile(L, LUAI_IO_OUTPUT), 1);
}
static int luai_f_write (lua_State *L) {
FILE *f = luai_tofile(L);
lua_pushvalue(L, 1); /* push file at the stack top (to be returned) */
return luai_g_write(L, f, 2);
}
static int luai_f_seek (lua_State *L) {
static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
static const char *const modenames[] = {"set", "cur", "end", NULL};
FILE *f = luai_tofile(L);
int op = luaL_checkoption(L, 2, "cur", modenames);
lua_Integer p3 = luaL_optinteger(L, 3, 0);
luai_l_seeknum offset = (luai_l_seeknum)p3;
luaL_argcheck(L, (lua_Integer)offset == p3, 3,
"not an integer in proper range");
op = luai_l_fseek(f, offset, mode[op]);
if (op)
return luaL_fileresult(L, 0, NULL); /* error */
else {
lua_pushinteger(L, (lua_Integer)luai_l_ftell(f));
return 1;
}
}
static int luai_f_setvbuf (lua_State *L) {
static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
static const char *const modenames[] = {"no", "full", "line", NULL};
FILE *f = luai_tofile(L);
int op = luaL_checkoption(L, 2, NULL, modenames);
lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
int res = setvbuf(f, NULL, mode[op], (size_t)sz);
return luaL_fileresult(L, res == 0, NULL);
}
static int luai_io_flush (lua_State *L) {
return luaL_fileresult(L, fflush(luai_getiofile(L, LUAI_IO_OUTPUT)) == 0, NULL);
}
static int luai_f_flush (lua_State *L) {
return luaL_fileresult(L, fflush(luai_tofile(L)) == 0, NULL);
}
/*
** functions for 'io' library
*/
static const luaL_Reg luai_iolib[] = {
{"close", luai_io_close},
{"flush", luai_io_flush},
{"input", luai_io_input},
{"lines", luai_io_lines},
{"open", luai_io_open},
{"output", luai_io_output},
{"popen", luai_io_popen},
{"read", luai_io_read},
{"tmpfile", luai_io_tmpfile},
{"type", luai_io_type},
{"write", luai_io_write},
{NULL, NULL}
};
/*
** methods for file handles
*/
static const luaL_Reg luai_flib[] = {
{"close", luai_io_close},
{"flush", luai_f_flush},
{"lines", luai_f_lines},
{"read", luai_f_read},
{"seek", luai_f_seek},
{"setvbuf", luai_f_setvbuf},
{"write", luai_f_write},
{"__gc", luai_f_gc},
{"__tostring", luai_f_tostring},
{NULL, NULL}
};
static void luai_createmeta (lua_State *L) {
luaL_newmetatable(L, LUA_FILEHANDLE); /* create metatable for file handles */
lua_pushvalue(L, -1); /* push metatable */
lua_setfield(L, -2, "__index"); /* metatable.__index = metatable */
luaL_setfuncs(L, luai_flib, 0); /* add file methods to new metatable */
lua_pop(L, 1); /* pop new metatable */
}
/*
** function to (not) close the standard files stdin, stdout, and stderr
*/
static int luai_io_noclose (lua_State *L) {
luai_LStream *p = luai_tolstream(L);
p->closef = &luai_io_noclose; /* keep file opened */
lua_pushnil(L);
lua_pushliteral(L, "cannot close standard file");
return 2;
}
static void luai_createstdfile (lua_State *L, FILE *f, const char *k,
const char *fname) {
luai_LStream *p = luai_toprefile(L);
p->f = f;
p->closef = &luai_io_noclose;
if (k != NULL) {
lua_pushvalue(L, -1);
lua_setfield(L, LUA_REGISTRYINDEX, k); /* add file to registry */
}
lua_setfield(L, -2, fname); /* add file to module */
}
LUAMOD_API int luaopen_io (lua_State *L) {
luaL_newlib(L, luai_iolib); /* new module */
luai_createmeta(L);
/* create (and set) default files */
luai_createstdfile(L, stdin, LUAI_IO_INPUT, "stdin");
luai_createstdfile(L, stdout, LUAI_IO_OUTPUT, "stdout");
luai_createstdfile(L, stderr, NULL, "stderr");
return 1;
}
/*__llex.c__*/
#define luai_next(ls) (ls->current = luai_zgetc(ls->z))
#define luai_currIsNewline(ls) (ls->current == '\n' || ls->current == '\r')
/* ORDER LUAI_RESERVED */
static const char *const luaX_tokens [] = {
"and", "break", "do", "else", "elseif",
"end", "false", "for", "function", "goto", "if",
"in", "local", "nil", "not", "or", "repeat",
"return", "then", "true", "until", "while",
"//", "..", "...", "==", ">=", "<=", "~=",
"<<", ">>", "::", "<eof>",
"<number>", "<integer>", "<name>", "<string>"
};
#define luai_save_and_next(ls) (luai_save(ls, ls->current), luai_next(ls))
static luai_l_noret luai_lexerror (luai_LexState *ls, const char *msg, int token);
static void luai_save (luai_LexState *ls, int c) {
luai_Mbuffer *b = ls->buff;
if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) {
size_t newsize;
if (luaZ_sizebuffer(b) >= LUAI_MAX_SIZE/2)
luai_lexerror(ls, "lexical element too long", 0);
newsize = luaZ_sizebuffer(b) * 2;
luaZ_resizebuffer(ls->L, b, newsize);
}
b->buffer[luaZ_bufflen(b)++] = luai_cast(char, c);
}
void luaX_init (lua_State *L) {
int i;
luai_TString *e = luaS_newliteral(L, LUA_ENV); /* create env name */
luaC_fix(L, luai_obj2gco(e)); /* never collect this name */
for (i=0; i<LUAI_NUM_RESERVED; i++) {
luai_TString *ts = luaS_new(L, luaX_tokens[i]);
luaC_fix(L, luai_obj2gco(ts)); /* reserved words are never collected */
ts->extra = luai_cast_byte(i+1); /* reserved word */
}
}
const char *luaX_token2str (luai_LexState *ls, int token) {
if (token < LUAI_FIRST_RESERVED) { /* single-byte symbols? */
lua_assert(token == luai_cast_uchar(token));
return luaO_pushfstring(ls->L, "'%c'", token);
}
else {
const char *s = luaX_tokens[token - LUAI_FIRST_RESERVED];
if (token < LUAI_TK_EOS) /* fixed format (symbols and reserved words)? */
return luaO_pushfstring(ls->L, "'%s'", s);
else /* names, strings, and numerals */
return s;
}
}
static const char *luai_txtToken (luai_LexState *ls, int token) {
switch (token) {
case LUAI_TK_NAME: case LUAI_TK_STRING:
case LUAI_TK_FLT: case LUAI_TK_INT:
luai_save(ls, '\0');
return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff));
default:
return luaX_token2str(ls, token);
}
}
static luai_l_noret luai_lexerror (luai_LexState *ls, const char *msg, int token) {
msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber);
if (token)
luaO_pushfstring(ls->L, "%s near %s", msg, luai_txtToken(ls, token));
luaD_throw(ls->L, LUA_ERRSYNTAX);
}
luai_l_noret luaX_syntaxerror (luai_LexState *ls, const char *msg) {
luai_lexerror(ls, msg, ls->t.token);
}
/*
** creates a new string and anchors it in scanner's table so that
** it will not be collected until the end of the compilation
** (by that time it should be anchored somewhere)
*/
luai_TString *luaX_newstring (luai_LexState *ls, const char *str, size_t l) {
lua_State *L = ls->L;
luai_TValue *o; /* entry for 'str' */
luai_TString *ts = luaS_newlstr(L, str, l); /* create new string */
luai_setsvalue2s(L, L->top++, ts); /* temporarily anchor it in stack */
o = luaH_set(L, ls->h, L->top - 1);
if (luai_ttisnil(o)) { /* not in use yet? */
/* boolean value does not need LUAI_GC barrier;
table has no metatable, so it does not need to invalidate cache */
luai_setbvalue(o, 1); /* t[string] = true */
luaC_checkGC(L);
}
else { /* string already present */
ts = luai_tsvalue(luai_keyfromval(o)); /* re-use value previously stored */
}
L->top--; /* remove string from stack */
return ts;
}
/*
** increment line number and skips newline sequence (any of
** \n, \r, \n\r, or \r\n)
*/
static void luai_inclinenumber (luai_LexState *ls) {
int old = ls->current;
lua_assert(luai_currIsNewline(ls));
luai_next(ls); /* skip '\n' or '\r' */
if (luai_currIsNewline(ls) && ls->current != old)
luai_next(ls); /* skip '\n\r' or '\r\n' */
if (++ls->linenumber >= LUAI_MAX_INT)
luai_lexerror(ls, "chunk has too many lines", 0);
}
void luaX_setinput (lua_State *L, luai_LexState *ls, LUAI_ZIO *z, luai_TString *source,
int firstchar) {
ls->t.token = 0;
ls->L = L;
ls->current = firstchar;
ls->lookahead.token = LUAI_TK_EOS; /* no look-ahead token */
ls->z = z;
ls->fs = NULL;
ls->linenumber = 1;
ls->lastline = 1;
ls->source = source;
ls->envn = luaS_newliteral(L, LUA_ENV); /* get env name */
luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */
}
/*
** =======================================================
** LEXICAL ANALYZER
** =======================================================
*/
static int luai_check_next1 (luai_LexState *ls, int c) {
if (ls->current == c) {
luai_next(ls);
return 1;
}
else return 0;
}
/*
** Check whether current char is in set 'set' (with two chars) and
** saves it
*/
static int luai_check_next2 (luai_LexState *ls, const char *set) {
lua_assert(set[2] == '\0');
if (ls->current == set[0] || ls->current == set[1]) {
luai_save_and_next(ls);
return 1;
}
else return 0;
}
/* LUA_NUMBER */
/*
** this function is quite liberal in what it accepts, as 'luaO_str2num'
** will reject ill-formed numerals.
*/
static int luai_read_numeral (luai_LexState *ls, luai_SemInfo *seminfo) {
luai_TValue obj;
const char *expo = "Ee";
int first = ls->current;
lua_assert(luai_lisdigit(ls->current));
luai_save_and_next(ls);
if (first == '0' && luai_check_next2(ls, "xX")) /* hexadecimal? */
expo = "Pp";
for (;;) {
if (luai_check_next2(ls, expo)) /* exponent part? */
luai_check_next2(ls, "-+"); /* optional exponent sign */
if (luai_lisxdigit(ls->current))
luai_save_and_next(ls);
else if (ls->current == '.')
luai_save_and_next(ls);
else break;
}
luai_save(ls, '\0');
if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */
luai_lexerror(ls, "malformed number", LUAI_TK_FLT);
if (luai_ttisinteger(&obj)) {
seminfo->i = luai_ivalue(&obj);
return LUAI_TK_INT;
}
else {
lua_assert(luai_ttisfloat(&obj));
seminfo->r = luai_fltvalue(&obj);
return LUAI_TK_FLT;
}
}
/*
** skip a sequence '[=*[' or ']=*]'; if sequence is well formed, return
** its number of '='s; otherwise, return a negative number (-1 iff there
** are no '='s after initial bracket)
*/
static int luai_skip_sep (luai_LexState *ls) {
int count = 0;
int s = ls->current;
lua_assert(s == '[' || s == ']');
luai_save_and_next(ls);
while (ls->current == '=') {
luai_save_and_next(ls);
count++;
}
return (ls->current == s) ? count : (-count) - 1;
}
static void luai_read_long_string (luai_LexState *ls, luai_SemInfo *seminfo, int sep) {
int line = ls->linenumber; /* initial line (for error message) */
luai_save_and_next(ls); /* skip 2nd '[' */
if (luai_currIsNewline(ls)) /* string starts with a newline? */
luai_inclinenumber(ls); /* skip it */
for (;;) {
switch (ls->current) {
case LUAI_EOZ: { /* error */
const char *what = (seminfo ? "string" : "comment");
const char *msg = luaO_pushfstring(ls->L,
"unfinished long %s (starting at line %d)", what, line);
luai_lexerror(ls, msg, LUAI_TK_EOS);
break; /* to avoid warnings */
}
case ']': {
if (luai_skip_sep(ls) == sep) {
luai_save_and_next(ls); /* skip 2nd ']' */
goto endloop;
}
break;
}
case '\n': case '\r': {
luai_save(ls, '\n');
luai_inclinenumber(ls);
if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */
break;
}
default: {
if (seminfo) luai_save_and_next(ls);
else luai_next(ls);
}
}
} endloop:
if (seminfo)
seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
luaZ_bufflen(ls->buff) - 2*(2 + sep));
}
static void luai_esccheck (luai_LexState *ls, int c, const char *msg) {
if (!c) {
if (ls->current != LUAI_EOZ)
luai_save_and_next(ls); /* add current to buffer for error message */
luai_lexerror(ls, msg, LUAI_TK_STRING);
}
}
static int luai_gethexa (luai_LexState *ls) {
luai_save_and_next(ls);
luai_esccheck (ls, luai_lisxdigit(ls->current), "hexadecimal luai_digit expected");
return luaO_hexavalue(ls->current);
}
static int luai_readhexaesc (luai_LexState *ls) {
int r = luai_gethexa(ls);
r = (r << 4) + luai_gethexa(ls);
luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */
return r;
}
static unsigned long luai_readutf8esc (luai_LexState *ls) {
unsigned long r;
int i = 4; /* chars to be removed: '\', 'u', '{', and first luai_digit */
luai_save_and_next(ls); /* skip 'u' */
luai_esccheck(ls, ls->current == '{', "missing '{'");
r = luai_gethexa(ls); /* must have at least one luai_digit */
while ((luai_save_and_next(ls), luai_lisxdigit(ls->current))) {
i++;
r = (r << 4) + luaO_hexavalue(ls->current);
luai_esccheck(ls, r <= 0x10FFFF, "UTF-8 value too large");
}
luai_esccheck(ls, ls->current == '}', "missing '}'");
luai_next(ls); /* skip '}' */
luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */
return r;
}
static void luai_utf8esc (luai_LexState *ls) {
char buff[LUAI_UTF8BUFFSZ];
int n = luaO_utf8esc(buff, luai_readutf8esc(ls));
for (; n > 0; n--) /* add 'buff' to string */
luai_save(ls, buff[LUAI_UTF8BUFFSZ - n]);
}
static int luai_readdecesc (luai_LexState *ls) {
int i;
int r = 0; /* result accumulator */
for (i = 0; i < 3 && luai_lisdigit(ls->current); i++) { /* read up to 3 digits */
r = 10*r + ls->current - '0';
luai_save_and_next(ls);
}
luai_esccheck(ls, r <= UCHAR_MAX, "decimal escape too large");
luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */
return r;
}
static void luai_read_string (luai_LexState *ls, int del, luai_SemInfo *seminfo) {
luai_save_and_next(ls); /* keep delimiter (for error messages) */
while (ls->current != del) {
switch (ls->current) {
case LUAI_EOZ:
luai_lexerror(ls, "unfinished string", LUAI_TK_EOS);
break; /* to avoid warnings */
case '\n':
case '\r':
luai_lexerror(ls, "unfinished string", LUAI_TK_STRING);
break; /* to avoid warnings */
case '\\': { /* escape sequences */
int c; /* final character to be saved */
luai_save_and_next(ls); /* keep '\\' for error messages */
switch (ls->current) {
case 'a': c = '\a'; goto luai_read_save;
case 'b': c = '\b'; goto luai_read_save;
case 'f': c = '\f'; goto luai_read_save;
case 'n': c = '\n'; goto luai_read_save;
case 'r': c = '\r'; goto luai_read_save;
case 't': c = '\t'; goto luai_read_save;
case 'v': c = '\v'; goto luai_read_save;
case 'x': c = luai_readhexaesc(ls); goto luai_read_save;
case 'u': luai_utf8esc(ls); goto no_save;
case '\n': case '\r':
luai_inclinenumber(ls); c = '\n'; goto only_save;
case '\\': case '\"': case '\'':
c = ls->current; goto luai_read_save;
case LUAI_EOZ: goto no_save; /* will raise an error luai_next loop */
case 'z': { /* zap following span of spaces */
luaZ_buffremove(ls->buff, 1); /* remove '\\' */
luai_next(ls); /* skip the 'z' */
while (luai_lisspace(ls->current)) {
if (luai_currIsNewline(ls)) luai_inclinenumber(ls);
else luai_next(ls);
}
goto no_save;
}
default: {
luai_esccheck(ls, luai_lisdigit(ls->current), "invalid escape sequence");
c = luai_readdecesc(ls); /* digital escape '\ddd' */
goto only_save;
}
}
luai_read_save:
luai_next(ls);
/* go through */
only_save:
luaZ_buffremove(ls->buff, 1); /* remove '\\' */
luai_save(ls, c);
/* go through */
no_save: break;
}
default:
luai_save_and_next(ls);
}
}
luai_save_and_next(ls); /* skip delimiter */
seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
luaZ_bufflen(ls->buff) - 2);
}
static int luai_llex (luai_LexState *ls, luai_SemInfo *seminfo) {
luaZ_resetbuffer(ls->buff);
for (;;) {
switch (ls->current) {
case '\n': case '\r': { /* line breaks */
luai_inclinenumber(ls);
break;
}
case ' ': case '\f': case '\t': case '\v': { /* spaces */
luai_next(ls);
break;
}
case '-': { /* '-' or '--' (comment) */
luai_next(ls);
if (ls->current != '-') return '-';
/* else is a comment */
luai_next(ls);
if (ls->current == '[') { /* long comment? */
int sep = luai_skip_sep(ls);
luaZ_resetbuffer(ls->buff); /* 'luai_skip_sep' may dirty the buffer */
if (sep >= 0) {
luai_read_long_string(ls, NULL, sep); /* skip long comment */
luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */
break;
}
}
/* else short comment */
while (!luai_currIsNewline(ls) && ls->current != LUAI_EOZ)
luai_next(ls); /* skip until end of line (or end of file) */
break;
}
case '[': { /* long string or simply '[' */
int sep = luai_skip_sep(ls);
if (sep >= 0) {
luai_read_long_string(ls, seminfo, sep);
return LUAI_TK_STRING;
}
else if (sep != -1) /* '[=...' missing second bracket */
luai_lexerror(ls, "invalid long string delimiter", LUAI_TK_STRING);
return '[';
}
case '=': {
luai_next(ls);
if (luai_check_next1(ls, '=')) return LUAI_TK_EQ;
else return '=';
}
case '<': {
luai_next(ls);
if (luai_check_next1(ls, '=')) return LUAI_TK_LE;
else if (luai_check_next1(ls, '<')) return LUAI_TK_SHL;
else return '<';
}
case '>': {
luai_next(ls);
if (luai_check_next1(ls, '=')) return LUAI_TK_GE;
else if (luai_check_next1(ls, '>')) return LUAI_TK_SHR;
else return '>';
}
case '/': {
luai_next(ls);
if (luai_check_next1(ls, '/')) return LUAI_TK_IDIV;
else return '/';
}
case '~': {
luai_next(ls);
if (luai_check_next1(ls, '=')) return LUAI_TK_NE;
else return '~';
}
case ':': {
luai_next(ls);
if (luai_check_next1(ls, ':')) return LUAI_TK_DBCOLON;
else return ':';
}
case '"': case '\'': { /* short literal strings */
luai_read_string(ls, ls->current, seminfo);
return LUAI_TK_STRING;
}
case '.': { /* '.', '..', '...', or number */
luai_save_and_next(ls);
if (luai_check_next1(ls, '.')) {
if (luai_check_next1(ls, '.'))
return LUAI_TK_DOTS; /* '...' */
else return LUAI_TK_CONCAT; /* '..' */
}
else if (!luai_lisdigit(ls->current)) return '.';
else return luai_read_numeral(ls, seminfo);
}
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': {
return luai_read_numeral(ls, seminfo);
}
case LUAI_EOZ: {
return LUAI_TK_EOS;
}
default: {
if (luai_lislalpha(ls->current)) { /* identifier or reserved word? */
luai_TString *ts;
do {
luai_save_and_next(ls);
} while (luai_lislalnum(ls->current));
ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
luaZ_bufflen(ls->buff));
seminfo->ts = ts;
if (luai_isreserved(ts)) /* reserved word? */
return ts->extra - 1 + LUAI_FIRST_RESERVED;
else {
return LUAI_TK_NAME;
}
}
else { /* single-char tokens (+ - / ...) */
int c = ls->current;
luai_next(ls);
return c;
}
}
}
}
}
void luaX_next (luai_LexState *ls) {
ls->lastline = ls->linenumber;
if (ls->lookahead.token != LUAI_TK_EOS) { /* is there a look-ahead token? */
ls->t = ls->lookahead; /* use this one */
ls->lookahead.token = LUAI_TK_EOS; /* and discharge it */
}
else
ls->t.token = luai_llex(ls, &ls->t.seminfo); /* read luai_next token */
}
int luaX_lookahead (luai_LexState *ls) {
lua_assert(ls->lookahead.token == LUAI_TK_EOS);
ls->lookahead.token = luai_llex(ls, &ls->lookahead.seminfo);
return ls->lookahead.token;
}
/*__lmathlib.c__*/
#define LUA_PI (luai_l_mathop(3.141592653589793238462643383279502884))
#if !defined(luai_l_rand) /* { */
#if defined(LUA_USE_POSIX)
#define luai_l_rand() random()
#define luai_l_srand(x) srandom(x)
#define LUAI_L_RANDMAX 2147483647 /* (2^31 - 1), following POSIX */
#else
#define luai_l_rand() rand()
#define luai_l_srand(x) srand(x)
#define LUAI_L_RANDMAX RAND_MAX
#endif
#endif /* } */
static int luai_math_abs (lua_State *L) {
if (lua_isinteger(L, 1)) {
lua_Integer n = lua_tointeger(L, 1);
if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n);
lua_pushinteger(L, n);
}
else
lua_pushnumber(L, luai_l_mathop(fabs)(luaL_checknumber(L, 1)));
return 1;
}
static int luai_math_sin (lua_State *L) {
lua_pushnumber(L, luai_l_mathop(sin)(luaL_checknumber(L, 1)));
return 1;
}
static int luai_math_cos (lua_State *L) {
lua_pushnumber(L, luai_l_mathop(cos)(luaL_checknumber(L, 1)));
return 1;
}
static int luai_math_tan (lua_State *L) {
lua_pushnumber(L, luai_l_mathop(tan)(luaL_checknumber(L, 1)));
return 1;
}
static int luai_math_asin (lua_State *L) {
lua_pushnumber(L, luai_l_mathop(asin)(luaL_checknumber(L, 1)));
return 1;
}
static int luai_math_acos (lua_State *L) {
lua_pushnumber(L, luai_l_mathop(acos)(luaL_checknumber(L, 1)));
return 1;
}
static int luai_math_atan (lua_State *L) {
lua_Number y = luaL_checknumber(L, 1);
lua_Number x = luaL_optnumber(L, 2, 1);
lua_pushnumber(L, luai_l_mathop(atan2)(y, x));
return 1;
}
static int luai_math_toint (lua_State *L) {
int valid;
lua_Integer n = lua_tointegerx(L, 1, &valid);
if (valid)
lua_pushinteger(L, n);
else {
luaL_checkany(L, 1);
lua_pushnil(L); /* value is not convertible to integer */
}
return 1;
}
static void luai_pushnumint (lua_State *L, lua_Number d) {
lua_Integer n;
if (lua_numbertointeger(d, &n)) /* does 'd' fit in an integer? */
lua_pushinteger(L, n); /* result is integer */
else
lua_pushnumber(L, d); /* result is float */
}
static int luai_math_floor (lua_State *L) {
if (lua_isinteger(L, 1))
lua_settop(L, 1); /* integer is its own floor */
else {
lua_Number d = luai_l_mathop(floor)(luaL_checknumber(L, 1));
luai_pushnumint(L, d);
}
return 1;
}
static int luai_math_ceil (lua_State *L) {
if (lua_isinteger(L, 1))
lua_settop(L, 1); /* integer is its own ceil */
else {
lua_Number d = luai_l_mathop(ceil)(luaL_checknumber(L, 1));
luai_pushnumint(L, d);
}
return 1;
}
static int luai_math_fmod (lua_State *L) {
if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
lua_Integer d = lua_tointeger(L, 2);
if ((lua_Unsigned)d + 1u <= 1u) { /* special cases: -1 or 0 */
luaL_argcheck(L, d != 0, 2, "zero");
lua_pushinteger(L, 0); /* avoid overflow with 0x80000... / -1 */
}
else
lua_pushinteger(L, lua_tointeger(L, 1) % d);
}
else
lua_pushnumber(L, luai_l_mathop(fmod)(luaL_checknumber(L, 1),
luaL_checknumber(L, 2)));
return 1;
}
/*
** luai_next function does not use 'modf', avoiding problems with 'double*'
** (which is not compatible with 'float*') when lua_Number is not
** 'double'.
*/
static int luai_math_modf (lua_State *L) {
if (lua_isinteger(L ,1)) {
lua_settop(L, 1); /* number is its own integer part */
lua_pushnumber(L, 0); /* no fractional part */
}
else {
lua_Number n = luaL_checknumber(L, 1);
/* integer part (rounds toward zero) */
lua_Number ip = (n < 0) ? luai_l_mathop(ceil)(n) : luai_l_mathop(floor)(n);
luai_pushnumint(L, ip);
/* fractional part (test needed for inf/-inf) */
lua_pushnumber(L, (n == ip) ? luai_l_mathop(0.0) : (n - ip));
}
return 2;
}
static int luai_math_sqrt (lua_State *L) {
lua_pushnumber(L, luai_l_mathop(sqrt)(luaL_checknumber(L, 1)));
return 1;
}
static int luai_math_ult (lua_State *L) {
lua_Integer a = luaL_checkinteger(L, 1);
lua_Integer b = luaL_checkinteger(L, 2);
lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
return 1;
}
static int luai_math_log (lua_State *L) {
lua_Number x = luaL_checknumber(L, 1);
lua_Number res;
if (lua_isnoneornil(L, 2))
res = luai_l_mathop(log)(x);
else {
lua_Number base = luaL_checknumber(L, 2);
#if !defined(LUA_USE_C89)
if (base == luai_l_mathop(2.0))
res = luai_l_mathop(log2)(x); else
#endif
if (base == luai_l_mathop(10.0))
res = luai_l_mathop(log10)(x);
else
res = luai_l_mathop(log)(x)/luai_l_mathop(log)(base);
}
lua_pushnumber(L, res);
return 1;
}
static int luai_math_exp (lua_State *L) {
lua_pushnumber(L, luai_l_mathop(exp)(luaL_checknumber(L, 1)));
return 1;
}
static int luai_math_deg (lua_State *L) {
lua_pushnumber(L, luaL_checknumber(L, 1) * (luai_l_mathop(180.0) / LUA_PI));
return 1;
}
static int luai_math_rad (lua_State *L) {
lua_pushnumber(L, luaL_checknumber(L, 1) * (LUA_PI / luai_l_mathop(180.0)));
return 1;
}
static int luai_math_min (lua_State *L) {
int n = lua_gettop(L); /* number of arguments */
int imin = 1; /* index of current minimum value */
int i;
luaL_argcheck(L, n >= 1, 1, "value expected");
for (i = 2; i <= n; i++) {
if (lua_compare(L, i, imin, LUA_OPLT))
imin = i;
}
lua_pushvalue(L, imin);
return 1;
}
static int luai_math_max (lua_State *L) {
int n = lua_gettop(L); /* number of arguments */
int imax = 1; /* index of current maximum value */
int i;
luaL_argcheck(L, n >= 1, 1, "value expected");
for (i = 2; i <= n; i++) {
if (lua_compare(L, imax, i, LUA_OPLT))
imax = i;
}
lua_pushvalue(L, imax);
return 1;
}
/*
** This function uses 'double' (instead of 'lua_Number') to ensure that
** all bits from 'luai_l_rand' can be represented, and that 'RANDMAX + 1.0'
** will keep full precision (ensuring that 'r' is always less than 1.0.)
*/
static int luai_math_random (lua_State *L) {
lua_Integer low, up;
double r = (double)luai_l_rand() * (1.0 / ((double)LUAI_L_RANDMAX + 1.0));
switch (lua_gettop(L)) { /* luai_check number of arguments */
case 0: { /* no arguments */
lua_pushnumber(L, (lua_Number)r); /* Number between 0 and 1 */
return 1;
}
case 1: { /* only upper limit */
low = 1;
up = luaL_checkinteger(L, 1);
break;
}
case 2: { /* lower and upper limits */
low = luaL_checkinteger(L, 1);
up = luaL_checkinteger(L, 2);
break;
}
default: return luaL_error(L, "wrong number of arguments");
}
/* random integer in the interval [low, up] */
luaL_argcheck(L, low <= up, 1, "interval is empty");
luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1,
"interval too large");
r *= (double)(up - low) + 1.0;
lua_pushinteger(L, (lua_Integer)r + low);
return 1;
}
static int luai_math_randomseed (lua_State *L) {
luai_l_srand((unsigned int)(lua_Integer)luaL_checknumber(L, 1));
(void)luai_l_rand(); /* discard first value to avoid undesirable correlations */
return 0;
}
static int luai_math_type (lua_State *L) {
if (lua_type(L, 1) == LUA_TNUMBER) {
if (lua_isinteger(L, 1))
lua_pushliteral(L, "integer");
else
lua_pushliteral(L, "float");
}
else {
luaL_checkany(L, 1);
lua_pushnil(L);
}
return 1;
}
/*
** {==================================================================
** Deprecated functions (for compatibility only)
** ===================================================================
*/
#if defined(LUA_COMPAT_MATHLIB)
static int luai_math_cosh (lua_State *L) {
lua_pushnumber(L, luai_l_mathop(cosh)(luaL_checknumber(L, 1)));
return 1;
}
static int luai_math_sinh (lua_State *L) {
lua_pushnumber(L, luai_l_mathop(sinh)(luaL_checknumber(L, 1)));
return 1;
}
static int luai_math_tanh (lua_State *L) {
lua_pushnumber(L, luai_l_mathop(tanh)(luaL_checknumber(L, 1)));
return 1;
}
static int luai_math_pow (lua_State *L) {
lua_Number x = luaL_checknumber(L, 1);
lua_Number y = luaL_checknumber(L, 2);
lua_pushnumber(L, luai_l_mathop(pow)(x, y));
return 1;
}
static int luai_math_frexp (lua_State *L) {
int e;
lua_pushnumber(L, luai_l_mathop(frexp)(luaL_checknumber(L, 1), &e));
lua_pushinteger(L, e);
return 2;
}
static int luai_math_ldexp (lua_State *L) {
lua_Number x = luaL_checknumber(L, 1);
int ep = (int)luaL_checkinteger(L, 2);
lua_pushnumber(L, luai_l_mathop(ldexp)(x, ep));
return 1;
}
static int luai_math_log10 (lua_State *L) {
lua_pushnumber(L, luai_l_mathop(log10)(luaL_checknumber(L, 1)));
return 1;
}
#endif
/* }================================================================== */
static const luaL_Reg luai_mathlib[] = {
{"abs", luai_math_abs},
{"acos", luai_math_acos},
{"asin", luai_math_asin},
{"atan", luai_math_atan},
{"ceil", luai_math_ceil},
{"cos", luai_math_cos},
{"deg", luai_math_deg},
{"exp", luai_math_exp},
{"tointeger", luai_math_toint},
{"floor", luai_math_floor},
{"fmod", luai_math_fmod},
{"ult", luai_math_ult},
{"log", luai_math_log},
{"max", luai_math_max},
{"min", luai_math_min},
{"modf", luai_math_modf},
{"rad", luai_math_rad},
{"random", luai_math_random},
{"randomseed", luai_math_randomseed},
{"sin", luai_math_sin},
{"sqrt", luai_math_sqrt},
{"tan", luai_math_tan},
{"type", luai_math_type},
#if defined(LUA_COMPAT_MATHLIB)
{"atan2", luai_math_atan},
{"cosh", luai_math_cosh},
{"sinh", luai_math_sinh},
{"tanh", luai_math_tanh},
{"pow", luai_math_pow},
{"frexp", luai_math_frexp},
{"ldexp", luai_math_ldexp},
{"log10", luai_math_log10},
#endif
/* placeholders */
{"pi", NULL},
{"huge", NULL},
{"maxinteger", NULL},
{"mininteger", NULL},
{NULL, NULL}
};
/*
** Open math library
*/
LUAMOD_API int luaopen_math (lua_State *L) {
luaL_newlib(L, luai_mathlib);
lua_pushnumber(L, LUA_PI);
lua_setfield(L, -2, "pi");
lua_pushnumber(L, (lua_Number)HUGE_VAL);
lua_setfield(L, -2, "huge");
lua_pushinteger(L, LUA_MAXINTEGER);
lua_setfield(L, -2, "maxinteger");
lua_pushinteger(L, LUA_MININTEGER);
lua_setfield(L, -2, "mininteger");
return 1;
}
/*__lmem.c__*/
/*
** About the realloc function:
** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
** ('osize' is the old size, 'nsize' is the new size)
**
** * frealloc(ud, NULL, x, s) creates a new luai_getblock of size 's' (no
** matter 'x').
**
** * frealloc(ud, p, x, 0) frees the luai_getblock 'p'
** (in this specific case, frealloc must return NULL);
** particularly, frealloc(ud, NULL, 0, 0) does nothing
** (which is equivalent to free(NULL) in ISO C)
**
** frealloc returns NULL if it cannot create or reallocate the area
** (any reallocation to an equal or smaller size cannot fail!)
*/
#define MINSIZEARRAY 4
void *luaM_growaux_ (lua_State *L, void *luai_getblock, int *size, size_t size_elems,
int limit, const char *what) {
void *newblock;
int newsize;
if (*size >= limit/2) { /* cannot double it? */
if (*size >= limit) /* cannot grow even a little? */
luaG_runerror(L, "too many %s (limit is %d)", what, limit);
newsize = limit; /* still have at least one free place */
}
else {
newsize = (*size)*2;
if (newsize < MINSIZEARRAY)
newsize = MINSIZEARRAY; /* minimum size */
}
newblock = luaM_reallocv(L, luai_getblock, *size, newsize, size_elems);
*size = newsize; /* update only when everything else is OK */
return newblock;
}
luai_l_noret luaM_toobig (lua_State *L) {
luaG_runerror(L, "memory allocation error: luai_getblock too big");
}
/*
** generic allocation routine.
*/
void *luaM_realloc_ (lua_State *L, void *luai_getblock, size_t osize, size_t nsize) {
void *newblock;
luai_global_State *g = LUAI_G(L);
size_t realosize = (luai_getblock) ? osize : 0;
lua_assert((realosize == 0) == (luai_getblock == NULL));
#if defined(HARDMEMTESTS)
if (nsize > realosize && g->gcrunning)
luaC_fullgc(L, 1); /* force a LUAI_GC whenever possible */
#endif
newblock = (*g->frealloc)(g->ud, luai_getblock, osize, nsize);
if (newblock == NULL && nsize > 0) {
lua_assert(nsize > realosize); /* cannot fail when shrinking a luai_getblock */
if (g->version) { /* is state fully built? */
luaC_fullgc(L, 1); /* try to free some memory... */
newblock = (*g->frealloc)(g->ud, luai_getblock, osize, nsize); /* try again */
}
if (newblock == NULL)
luaD_throw(L, LUA_ERRMEM);
}
lua_assert((nsize == 0) == (newblock == NULL));
g->LUAI_GCdebt = (g->LUAI_GCdebt + nsize) - realosize;
return newblock;
}
/*__loadlib.c__*/
/*
** LUA_IGMARK is a mark to ignore all before it when building the
** luaopen_ function name.
*/
#if !defined (LUA_IGMARK)
#define LUA_IGMARK "-"
#endif
/*
** LUA_CSUBSEP is the character that replaces dots in submodule names
** when searching for a C loader.
** LUA_LSUBSEP is the character that replaces dots in submodule names
** when searching for a Lua loader.
*/
#if !defined(LUA_CSUBSEP)
#define LUA_CSUBSEP LUA_DIRSEP
#endif
#if !defined(LUA_LSUBSEP)
#define LUA_LSUBSEP LUA_DIRSEP
#endif
/* prefix for open functions in C libraries */
#define LUA_POF "luaopen_"
/* separator for open functions in C libraries */
#define LUA_OFSEP "_"
/*
** unique key for table in the registry that keeps handles
** for all loaded C libraries
*/
static const int LUAI_CLIBS = 0;
#define LUAI_LIB_FAIL "open"
#define luai_setprogdir(L) ((void)0)
/*
** system-dependent functions
*/
/*
** unload library 'lib'
*/
static void luai_lsys_unloadlib (void *lib);
/*
** load C library in file 'path'. If 'seeglb', load with all names in
** the library global.
** Returns the library; in case of error, returns NULL plus an
** error string in the stack.
*/
static void *luai_lsys_load (lua_State *L, const char *path, int seeglb);
/*
** Try to find a function named 'sym' in library 'lib'.
** Returns the function; in case of error, returns NULL plus an
** error string in the stack.
*/
static lua_CFunction luai_lsys_sym (lua_State *L, void *lib, const char *sym);
#if defined(LUA_USE_DLOPEN) /* { */
/*
** {========================================================================
** This is an implementation of loadlib based on the dlfcn interface.
** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
** NetBSD, AIX 4.2, HPUX 11, and probably most other Unix flavors, at least
** as an emulation layer on top of native functions.
** =========================================================================
*/
#include <dlfcn.h>
/*
** Macro to convert pointer-to-void* to pointer-to-function. This luai_cast
** is undefined according to ISO C, but POSIX assumes that it works.
** (The '__extension__' in gnu compilers is only to avoid warnings.)
*/
#if defined(__GNUC__)
#define luai_cast_func(p) (__extension__ (lua_CFunction)(p))
#else
#define luai_cast_func(p) ((lua_CFunction)(p))
#endif
static void luai_lsys_unloadlib (void *lib) {
dlclose(lib);
}
static void *luai_lsys_load (lua_State *L, const char *path, int seeglb) {
void *lib = dlopen(path, RTLD_NOW | (seeglb ? RTLD_GLOBAL : RTLD_LOCAL));
if (lib == NULL) lua_pushstring(L, dlerror());
return lib;
}
static lua_CFunction luai_lsys_sym (lua_State *L, void *lib, const char *sym) {
lua_CFunction f = luai_cast_func(dlsym(lib, sym));
if (f == NULL) lua_pushstring(L, dlerror());
return f;
}
/* }====================================================== */
#elif defined(LUA_DL_DLL) /* }{ */
/*
** {======================================================================
** This is an implementation of loadlib for Windows using native functions.
** =======================================================================
*/
#include <windows.h>
/*
** optional flags for LoadLibraryEx
*/
#if !defined(LUA_LLE_FLAGS)
#define LUA_LLE_FLAGS 0
#endif
#undef luai_setprogdir
/*
** Replace in the path (on the top of the stack) any occurrence
** of LUA_EXEC_DIR with the executable's path.
*/
static void luai_setprogdir (lua_State *L) {
char buff[MAX_PATH + 1];
char *lb;
DWORD nsize = sizeof(buff)/sizeof(char);
DWORD n = GetModuleFileNameA(NULL, buff, nsize); /* get exec. name */
if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
luaL_error(L, "unable to get ModuleFileName");
else {
*lb = '\0'; /* cut name on the last '\\' to get the path */
luaL_gsub(L, lua_tostring(L, -1), LUA_EXEC_DIR, buff);
lua_remove(L, -2); /* remove original string */
}
}
static void luai_pusherror (lua_State *L) {
int error = GetLastError();
char buffer[128];
if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, error, 0, buffer, sizeof(buffer)/sizeof(char), NULL))
lua_pushstring(L, buffer);
else
lua_pushfstring(L, "system error %d\n", error);
}
static void luai_lsys_unloadlib (void *lib) {
FreeLibrary((HMODULE)lib);
}
static void *luai_lsys_load (lua_State *L, const char *path, int seeglb) {
HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS);
(void)(seeglb); /* not used: symbols are 'global' by default */
if (lib == NULL) luai_pusherror(L);
return lib;
}
static lua_CFunction luai_lsys_sym (lua_State *L, void *lib, const char *sym) {
lua_CFunction f = (lua_CFunction)GetProcAddress((HMODULE)lib, sym);
if (f == NULL) luai_pusherror(L);
return f;
}
/* }====================================================== */
#else /* }{ */
/*
** {======================================================
** Fallback for other systems
** =======================================================
*/
#undef LUAI_LIB_FAIL
#define LUAI_LIB_FAIL "absent"
#define LUAI_DLMSG "dynamic libraries not enabled; luai_check your Lua installation"
static void luai_lsys_unloadlib (void *lib) {
(void)(lib); /* not used */
}
static void *luai_lsys_load (lua_State *L, const char *path, int seeglb) {
(void)(path); (void)(seeglb); /* not used */
lua_pushliteral(L, LUAI_DLMSG);
return NULL;
}
static lua_CFunction luai_lsys_sym (lua_State *L, void *lib, const char *sym) {
(void)(lib); (void)(sym); /* not used */
lua_pushliteral(L, LUAI_DLMSG);
return NULL;
}
/* }====================================================== */
#endif /* } */
/*
** {==================================================================
** Set Paths
** ===================================================================
*/
/*
** LUA_PATH_VAR and LUA_CPATH_VAR are the names of the environment
** variables that Lua luai_check to set its paths.
*/
#if !defined(LUA_PATH_VAR)
#define LUA_PATH_VAR "LUA_PATH"
#endif
#if !defined(LUA_CPATH_VAR)
#define LUA_CPATH_VAR "LUA_CPATH"
#endif
#define LUAI_AUXMARK "\1" /* auxiliary mark */
/*
** return registry.LUA_NOENV as a boolean
*/
static int luai_noenv (lua_State *L) {
int b;
lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
b = lua_toboolean(L, -1);
lua_pop(L, 1); /* remove value */
return b;
}
/*
** Set a path
*/
static void luai_setpath (lua_State *L, const char *fieldname,
const char *envname,
const char *dft) {
const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX);
const char *path = getenv(nver); /* use versioned name */
if (path == NULL) /* no environment variable? */
path = getenv(envname); /* try unversioned name */
if (path == NULL || luai_noenv(L)) /* no environment variable? */
lua_pushstring(L, dft); /* use default */
else {
/* replace ";;" by ";LUAI_AUXMARK;" and then LUAI_AUXMARK by default path */
path = luaL_gsub(L, path, LUA_PATH_SEP LUA_PATH_SEP,
LUA_PATH_SEP LUAI_AUXMARK LUA_PATH_SEP);
luaL_gsub(L, path, LUAI_AUXMARK, dft);
lua_remove(L, -2); /* remove result from 1st 'gsub' */
}
luai_setprogdir(L);
lua_setfield(L, -3, fieldname); /* package[fieldname] = path value */
lua_pop(L, 1); /* pop versioned variable name */
}
/* }================================================================== */
/*
** return registry.LUAI_CLIBS[path]
*/
static void *luai_checkclib (lua_State *L, const char *path) {
void *plib;
lua_rawgetp(L, LUA_REGISTRYINDEX, &LUAI_CLIBS);
lua_getfield(L, -1, path);
plib = lua_touserdata(L, -1); /* plib = LUAI_CLIBS[path] */
lua_pop(L, 2); /* pop LUAI_CLIBS table and 'plib' */
return plib;
}
/*
** registry.LUAI_CLIBS[path] = plib -- for queries
** registry.LUAI_CLIBS[#LUAI_CLIBS + 1] = plib -- also keep a list of all libraries
*/
static void luai_addtoclib (lua_State *L, const char *path, void *plib) {
lua_rawgetp(L, LUA_REGISTRYINDEX, &LUAI_CLIBS);
lua_pushlightuserdata(L, plib);
lua_pushvalue(L, -1);
lua_setfield(L, -3, path); /* LUAI_CLIBS[path] = plib */
lua_rawseti(L, -2, luaL_len(L, -2) + 1); /* LUAI_CLIBS[#LUAI_CLIBS + 1] = plib */
lua_pop(L, 1); /* pop LUAI_CLIBS table */
}
/*
** __gc tag method for LUAI_CLIBS table: calls 'luai_lsys_unloadlib' for all lib
** handles in list LUAI_CLIBS
*/
static int luai_gctm (lua_State *L) {
lua_Integer n = luaL_len(L, 1);
for (; n >= 1; n--) { /* for each handle, in reverse order */
lua_rawgeti(L, 1, n); /* get handle LUAI_CLIBS[n] */
luai_lsys_unloadlib(lua_touserdata(L, -1));
lua_pop(L, 1); /* pop handle */
}
return 0;
}
/* error codes for 'luai_lookforfunc' */
#define LUAI_ERRLIB 1
#define LUAI_ERRFUNC 2
/*
** Look for a C function named 'sym' in a dynamically loaded library
** 'path'.
** First, luai_check whether the library is already loaded; if not, try
** to load it.
** Then, if 'sym' is '*', return true (as library has been loaded).
** Otherwise, look for symbol 'sym' in the library and push a
** C function with that symbol.
** Return 0 and 'true' or a function in the stack; in case of
** errors, return an error code and an error message in the stack.
*/
static int luai_lookforfunc (lua_State *L, const char *path, const char *sym) {
void *reg = luai_checkclib(L, path); /* luai_check loaded C libraries */
if (reg == NULL) { /* must load library? */
reg = luai_lsys_load(L, path, *sym == '*'); /* global symbols if 'sym'=='*' */
if (reg == NULL) return LUAI_ERRLIB; /* unable to load library */
luai_addtoclib(L, path, reg);
}
if (*sym == '*') { /* loading only library (no function)? */
lua_pushboolean(L, 1); /* return 'true' */
return 0; /* no errors */
}
else {
lua_CFunction f = luai_lsys_sym(L, reg, sym);
if (f == NULL)
return LUAI_ERRFUNC; /* unable to find function */
lua_pushcfunction(L, f); /* else create new function */
return 0; /* no errors */
}
}
static int luai_ll_loadlib (lua_State *L) {
const char *path = luaL_checkstring(L, 1);
const char *init = luaL_checkstring(L, 2);
int stat = luai_lookforfunc(L, path, init);
if (stat == 0) /* no errors? */
return 1; /* return the loaded function */
else { /* error; error message is on stack top */
lua_pushnil(L);
lua_insert(L, -2);
lua_pushstring(L, (stat == LUAI_ERRLIB) ? LUAI_LIB_FAIL : "init");
return 3; /* return nil, error message, and where */
}
}
/*
** {======================================================
** 'require' function
** =======================================================
*/
static int luai_readable (const char *filename) {
FILE *f = fopen(filename, "r"); /* try to open file */
if (f == NULL) return 0; /* open failed */
fclose(f);
return 1;
}
static const char *luai_pushnexttemplate (lua_State *L, const char *path) {
const char *l;
while (*path == *LUA_PATH_SEP) path++; /* skip separators */
if (*path == '\0') return NULL; /* no more templates */
l = strchr(path, *LUA_PATH_SEP); /* find luai_next separator */
if (l == NULL) l = path + strlen(path);
lua_pushlstring(L, path, l - path); /* template */
return l;
}
static const char *luai_searchpath (lua_State *L, const char *name,
const char *path,
const char *sep,
const char *dirsep) {
luaL_Buffer msg; /* to build error message */
luaL_buffinit(L, &msg);
if (*sep != '\0') /* non-empty separator? */
name = luaL_gsub(L, name, sep, dirsep); /* replace it by 'dirsep' */
while ((path = luai_pushnexttemplate(L, path)) != NULL) {
const char *filename = luaL_gsub(L, lua_tostring(L, -1),
LUA_PATH_MARK, name);
lua_remove(L, -2); /* remove path template */
if (luai_readable(filename)) /* does file exist and is luai_readable? */
return filename; /* return that file name */
lua_pushfstring(L, "\n\tno file '%s'", filename);
lua_remove