-
-
Save jbush001/3facc41447f9520d9b5c to your computer and use it in GitHub Desktop.
ltable-25a254.c
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# 1 "<built-in>" | |
# 1 "ltable.c" | |
/* | |
** $Id: ltable.c,v 2.72.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Lua tables (hash) | |
** See Copyright Notice in lua.h | |
*/ | |
/* | |
** Implementation of tables (aka arrays, objects, or hash tables). | |
** Tables keep its elements in two parts: an array part and a hash part. | |
** Non-negative integer keys are all candidates to be kept in the array | |
** part. The actual size of the array is the largest `n' such that at | |
** least half the slots between 0 and n are in use. | |
** Hash uses a mix of chained scatter table with Brent's variation. | |
** A main invariant of these tables is that, if an element is not | |
** in its main position (i.e. the `original' position that its hash gives | |
** to it), then the colliding element is in its own main position. | |
** Hence even when the load factor reaches 100%, performance remains good. | |
*/ | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <string.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 21 "ltable.c" | |
# 1 "../../libc/include/string.h" 1 | |
// | |
// Copyright (C) 2014 Jeff Bush | |
// | |
// This library is free software; you can redistribute it and/or | |
// modify it under the terms of the GNU Library General Public | |
// License as published by the Free Software Foundation; either | |
// version 2 of the License, or (at your option) any later version. | |
// | |
// This library is distributed in the hope that it will be useful, | |
// but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
// Library General Public License for more details. | |
// | |
// You should have received a copy of the GNU Library General Public | |
// License along with this library; if not, write to the | |
// Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, | |
// Boston, MA 02110-1301, USA. | |
// | |
#ifndef __STRING_H | |
#define __STRING_H | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <stddef.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 23 "../../libc/include/string.h" | |
# 1 "../../libc/include/stddef.h" 1 | |
// | |
// Copyright (C) 2014 Jeff Bush | |
// | |
// This library is free software; you can redistribute it and/or | |
// modify it under the terms of the GNU Library General Public | |
// License as published by the Free Software Foundation; either | |
// version 2 of the License, or (at your option) any later version. | |
// | |
// This library is distributed in the hope that it will be useful, | |
// but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
// Library General Public License for more details. | |
// | |
// You should have received a copy of the GNU Library General Public | |
// License along with this library; if not, write to the | |
// Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, | |
// Boston, MA 02110-1301, USA. | |
// | |
#ifndef __STDDEF_H | |
#define __STDDEF_H | |
#define NULL 0 | |
typedef unsigned int size_t; | |
typedef int ptrdiff_t; | |
#define offsetof(__type__, __member__) ((size_t) (&((__type__*) 0)->__member__)) | |
#endif | |
# 31 "../../libc/include/stddef.h" | |
# 24 "../../libc/include/string.h" 2 | |
#ifdef __cplusplus | |
extern "C" { | |
#endif | |
# 28 "../../libc/include/string.h" | |
void *memcpy(void *dest, const void *src, size_t length); | |
void *memset(void *dest, int value, size_t length); | |
int strcmp(const char *str1, const char *str2); | |
int strcasecmp(const char *str1, const char *str2); | |
int strncasecmp(const char *str1, const char *str2, size_t length); | |
size_t strlen(const char *str); | |
char* strcpy(char *dest, const char *src); | |
char* strncpy(char *dest, const char *src, size_t length); | |
char *strchr(const char *string, int c); | |
char *strcat(char *c, const char *s); | |
#ifdef __cplusplus | |
} | |
#endif | |
# 43 "../../libc/include/string.h" | |
#endif | |
# 45 "../../libc/include/string.h" | |
# 22 "ltable.c" 2 | |
#define ltable_c | |
#define LUA_CORE | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lua.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 26 "ltable.c" | |
# 1 "./lua.h" 1 | |
/* | |
** $Id: lua.h,v 1.285.1.2 2013/11/11 12:09:16 roberto Exp $ | |
** Lua - A Scripting Language | |
** Lua.org, PUC-Rio, Brazil (http://www.lua.org) | |
** See Copyright Notice at the end of this file | |
*/ | |
#ifndef lua_h | |
#define lua_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <stdarg.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 12 "./lua.h" | |
# 1 "../../libc/include/stdarg.h" 1 | |
// | |
// Copyright (C) 2014 Jeff Bush | |
// | |
// This library is free software; you can redistribute it and/or | |
// modify it under the terms of the GNU Library General Public | |
// License as published by the Free Software Foundation; either | |
// version 2 of the License, or (at your option) any later version. | |
// | |
// This library is distributed in the hope that it will be useful, | |
// but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
// Library General Public License for more details. | |
// | |
// You should have received a copy of the GNU Library General Public | |
// License along with this library; if not, write to the | |
// Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, | |
// Boston, MA 02110-1301, USA. | |
// | |
#ifndef __STDARG_H | |
#define __STDARG_H | |
#define va_start(AP, LASTARG) __builtin_va_start(AP, LASTARG); | |
#define va_arg(AP, TYPE) __builtin_va_arg(AP, TYPE) | |
#define va_end(AP) __builtin_va_end(AP) | |
#define va_list __builtin_va_list | |
#endif | |
# 29 "../../libc/include/stdarg.h" | |
# 13 "./lua.h" 2 | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <stddef.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 13 "./lua.h" | |
# 14 "./lua.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "luaconf.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 16 "./lua.h" | |
# 1 "./luaconf.h" 1 | |
/* | |
** $Id: luaconf.h,v 1.176.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Configuration file for Lua | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef lconfig_h | |
#define lconfig_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <limits.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 11 "./luaconf.h" | |
# 1 "../../libc/include/limits.h" 1 | |
// | |
// Copyright (C) 2014 Jeff Bush | |
// | |
// This library is free software; you can redistribute it and/or | |
// modify it under the terms of the GNU Library General Public | |
// License as published by the Free Software Foundation; either | |
// version 2 of the License, or (at your option) any later version. | |
// | |
// This library is distributed in the hope that it will be useful, | |
// but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
// Library General Public License for more details. | |
// | |
// You should have received a copy of the GNU Library General Public | |
// License along with this library; if not, write to the | |
// Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, | |
// Boston, MA 02110-1301, USA. | |
// | |
#ifndef __LIMITS_H | |
#define __LIMITS_H | |
#define INT8_MIN 0x80 | |
#define INT8_MAX 0x7f | |
#define UCHAR_MAX 0xff | |
#define INT16_MIN 0x8000 | |
#define INT16_MAX 0x7fff | |
#define SHRT_MIN 0x8000 | |
#define SHRT_MAX 0x7fff | |
#define INT32_MIN 0x80000000L | |
#define INT32_MAX 0x7fffffffL | |
#define INT_MAX 0x7fffffff | |
#define INT64_MIN 0x8000000000000000LL | |
#define INT64_MAX 0x7fffffffffffffffLL | |
#define UINT8_MAX 0xff | |
#define UINT16_MAX 0xffff | |
#define UINT32_MAX 0xffffffffL | |
#endif | |
# 40 "../../libc/include/limits.h" | |
# 12 "./luaconf.h" 2 | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <stddef.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 12 "./luaconf.h" | |
# 13 "./luaconf.h" | |
/* | |
** ================================================================== | |
** Search for "@@" to find all configurable definitions. | |
** =================================================================== | |
*/ | |
// XXX nyuzi | |
#define getlocaledecpoint() '.' | |
#define luai_makeseed() __builtin_nyuzi_read_control_reg(6) | |
/* | |
@@ LUA_ANSI controls the use of non-ansi features. | |
** CHANGE it (define it) if you want Lua to avoid the use of any | |
** non-ansi feature or library. | |
*/ | |
#if !defined(LUA_ANSI) && defined(__STRICT_ANSI__) | |
#define LUA_ANSI | |
#endif | |
# 34 "./luaconf.h" | |
#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE) | |
#define LUA_WIN /* enable goodies for regular Windows platforms */ | |
#endif | |
# 39 "./luaconf.h" | |
#if defined(LUA_WIN) | |
#define LUA_DL_DLL | |
#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ | |
#endif | |
# 44 "./luaconf.h" | |
#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 */ | |
#define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */ | |
#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ | |
#define LUA_USE_LONGLONG /* assume support for long long */ | |
#endif | |
# 55 "./luaconf.h" | |
#if defined(LUA_USE_MACOSX) | |
#define LUA_USE_POSIX | |
#define LUA_USE_DLOPEN /* does not need -ldl */ | |
#define LUA_USE_READLINE /* needs an extra library: -lreadline */ | |
#define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */ | |
#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ | |
#define LUA_USE_LONGLONG /* assume support for long long */ | |
#endif | |
# 64 "./luaconf.h" | |
/* | |
@@ LUA_USE_POSIX includes all functionality listed as X/Open System | |
@* Interfaces Extension (XSI). | |
** CHANGE it (define it) if your system is XSI compatible. | |
*/ | |
#if defined(LUA_USE_POSIX) | |
#define LUA_USE_MKSTEMP | |
#define LUA_USE_ISATTY | |
#define LUA_USE_POPEN | |
#define LUA_USE_ULONGJMP | |
#define LUA_USE_GMTIME_R | |
#endif | |
# 79 "./luaconf.h" | |
/* | |
@@ 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. | |
*/ | |
#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_PATH_DEFAULT \ | |
LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ | |
LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" ".\\?.lua" | |
#define LUA_CPATH_DEFAULT \ | |
LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll" | |
#else /* }{ */ | |
# 105 "./luaconf.h" | |
#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/" | |
#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" | |
#define LUA_CPATH_DEFAULT \ | |
LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so" | |
#endif /* } */ | |
# 116 "./luaconf.h" | |
/* | |
@@ 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 | |
# 126 "./luaconf.h" | |
#define LUA_DIRSEP "/" | |
#endif | |
# 128 "./luaconf.h" | |
/* | |
@@ LUA_ENV is the name of the variable that holds the current | |
@@ environment, used to access global names. | |
** CHANGE it if you do not like this name. | |
*/ | |
#define LUA_ENV "_ENV" | |
/* | |
@@ 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 /* }{ */ | |
# 152 "./luaconf.h" | |
#define LUA_API __declspec(dllimport) | |
#endif /* } */ | |
# 154 "./luaconf.h" | |
#else /* }{ */ | |
# 156 "./luaconf.h" | |
#define LUA_API extern | |
#endif /* } */ | |
# 160 "./luaconf.h" | |
/* 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 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 | |
#define LUAI_DDEC LUAI_FUNC | |
#define LUAI_DDEF /* empty */ | |
#else /* }{ */ | |
# 188 "./luaconf.h" | |
#define LUAI_FUNC extern | |
#define LUAI_DDEC extern | |
#define LUAI_DDEF /* empty */ | |
#endif /* } */ | |
# 192 "./luaconf.h" | |
/* | |
@@ LUA_QL describes how error messages quote program elements. | |
** CHANGE it if you want a different appearance. | |
*/ | |
#define LUA_QL(x) "'" x "'" | |
#define LUA_QS LUA_QL("%s") | |
/* | |
@@ 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 | |
/* | |
@@ luai_writestring/luai_writeline define how 'print' prints its results. | |
** They are only used in libraries and the stand-alone program. (The #if | |
** avoids including 'stdio.h' everywhere.) | |
*/ | |
#if defined(LUA_LIB) || defined(lua_c) | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <stdio.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 217 "./luaconf.h" | |
# 218 "./luaconf.h" | |
#define luai_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) | |
#define luai_writeline() (luai_writestring("\n", 1), fflush(stdout)) | |
#endif | |
# 221 "./luaconf.h" | |
/* | |
@@ luai_writestringerror defines how to print error messages. | |
** (A format string with one argument is enough for Lua...) | |
*/ | |
#define luai_writestringerror(s,p) \ | |
(fprintf(stderr, (s), (p)), fflush(stderr)) | |
/* | |
@@ LUAI_MAXSHORTLEN is the 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.) | |
*/ | |
#define LUAI_MAXSHORTLEN 40 | |
/* | |
** {================================================================== | |
** Compatibility with previous versions | |
** =================================================================== | |
*/ | |
/* | |
@@ LUA_COMPAT_ALL controls all compatibility options. | |
** You can define it to get all options, or change specific options | |
** to fit your specific needs. | |
*/ | |
#if defined(LUA_COMPAT_ALL) /* { */ | |
/* | |
@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'. | |
** You can replace it with 'table.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 '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 /* } */ | |
# 311 "./luaconf.h" | |
/* }================================================================== */ | |
/* | |
@@ LUAI_BITSINT defines the number of bits in an int. | |
** CHANGE here if Lua cannot automatically detect the number of bits of | |
** your machine. Probably you do not need to change this. | |
*/ | |
/* avoid overflows in comparison */ | |
#if INT_MAX-20 < 32760 /* { */ | |
#define LUAI_BITSINT 16 | |
#elif INT_MAX > 2147483640L /* }{ */ | |
# 325 "./luaconf.h" | |
/* int has at least 32 bits */ | |
#define LUAI_BITSINT 32 | |
#else /* }{ */ | |
# 328 "./luaconf.h" | |
#error "you must define LUA_BITSINT with number of bits in an integer" | |
#endif /* } */ | |
# 330 "./luaconf.h" | |
/* | |
@@ LUA_INT32 is an signed integer with exactly 32 bits. | |
@@ LUAI_UMEM is an unsigned integer big enough to count the total | |
@* memory used by Lua. | |
@@ LUAI_MEM is a signed integer big enough to count the total memory | |
@* used by Lua. | |
** CHANGE here if for some weird reason the default definitions are not | |
** good enough for your machine. Probably you do not need to change | |
** this. | |
*/ | |
#if LUAI_BITSINT >= 32 /* { */ | |
#define LUA_INT32 int | |
#define LUAI_UMEM size_t | |
#define LUAI_MEM ptrdiff_t | |
#else /* }{ */ | |
# 347 "./luaconf.h" | |
/* 16-bit ints */ | |
#define LUA_INT32 long | |
#define LUAI_UMEM unsigned long | |
#define LUAI_MEM long | |
#endif /* } */ | |
# 352 "./luaconf.h" | |
/* | |
@@ 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 to consume unlimited stack | |
** space (and to reserve some numbers for pseudo-indices). | |
*/ | |
#if LUAI_BITSINT >= 32 | |
#define LUAI_MAXSTACK 1000000 | |
#else | |
# 363 "./luaconf.h" | |
#define LUAI_MAXSTACK 15000 | |
#endif | |
# 365 "./luaconf.h" | |
/* reserve some space for error handling */ | |
#define LUAI_FIRSTPSEUDOIDX (-LUAI_MAXSTACK - 1000) | |
/* | |
@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. | |
** CHANGE it if it uses too much C-stack space. | |
*/ | |
#define LUAL_BUFFERSIZE BUFSIZ | |
/* | |
** {================================================================== | |
@@ LUA_NUMBER is the type of numbers in Lua. | |
** CHANGE the following definitions only if you want to build Lua | |
** with a number type different from double. You may also need to | |
** change lua_number2int & lua_number2integer. | |
** =================================================================== | |
*/ | |
#define LUA_NUMBER_DOUBLE | |
#define LUA_NUMBER double | |
/* | |
@@ LUAI_UACNUMBER is the result of an 'usual argument conversion' | |
@* over a number. | |
*/ | |
#define LUAI_UACNUMBER double | |
/* | |
@@ LUA_NUMBER_SCAN is the format for reading numbers. | |
@@ LUA_NUMBER_FMT is the format for writing numbers. | |
@@ lua_number2str converts a number to a string. | |
@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion. | |
*/ | |
#define LUA_NUMBER_SCAN "%lf" | |
#define LUA_NUMBER_FMT "%.14g" | |
#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) | |
#define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */ | |
/* | |
@@ l_mathop allows the addition of an 'l' or 'f' to all math operations | |
*/ | |
#define l_mathop(x) (x) | |
/* | |
@@ lua_str2number converts a decimal numeric string to a number. | |
@@ lua_strx2number converts an hexadecimal numeric string to a number. | |
** In C99, 'strtod' does both conversions. C89, however, has no function | |
** to convert floating hexadecimal strings to numbers. For these | |
** systems, you can leave 'lua_strx2number' undefined and Lua will | |
** provide its own implementation. | |
*/ | |
#define lua_str2number(s,p) strtod((s), (p)) | |
#if defined(LUA_USE_STRTODHEX) | |
#define lua_strx2number(s,p) strtod((s), (p)) | |
#endif | |
# 431 "./luaconf.h" | |
/* | |
@@ The luai_num* macros define the primitive operations over numbers. | |
*/ | |
/* the following operations need the math library */ | |
#if defined(lobject_c) || defined(lvm_c) | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <math.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 439 "./luaconf.h" | |
# 440 "./luaconf.h" | |
#define luai_nummod(L,a,b) ((a) - l_mathop(floor)((a)/(b))*(b)) | |
#define luai_numpow(L,a,b) (l_mathop(pow)(a,b)) | |
#endif | |
# 443 "./luaconf.h" | |
/* these are quite standard operations */ | |
#if defined(LUA_CORE) | |
#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_numdiv(L,a,b) ((a)/(b)) | |
#define luai_numunm(L,a) (-(a)) | |
#define luai_numeq(a,b) ((a)==(b)) | |
#define luai_numlt(L,a,b) ((a)<(b)) | |
#define luai_numle(L,a,b) ((a)<=(b)) | |
#define luai_numisnan(L,a) (!luai_numeq((a), (a))) | |
#endif | |
# 456 "./luaconf.h" | |
/* | |
@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger. | |
** CHANGE that if ptrdiff_t is not adequate on your machine. (On most | |
** machines, ptrdiff_t gives a good choice between int or long.) | |
*/ | |
#define LUA_INTEGER ptrdiff_t | |
/* | |
@@ LUA_UNSIGNED is the integral type used by lua_pushunsigned/lua_tounsigned. | |
** It must have at least 32 bits. | |
*/ | |
#define LUA_UNSIGNED unsigned LUA_INT32 | |
/* | |
** Some tricks with doubles | |
*/ | |
#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) /* { */ | |
/* | |
** The next definitions activate some tricks to speed up the | |
** conversion from doubles to integer types, mainly to LUA_UNSIGNED. | |
** | |
@@ LUA_MSASMTRICK uses Microsoft assembler to avoid clashes with a | |
** DirectX idiosyncrasy. | |
** | |
@@ LUA_IEEE754TRICK uses a trick that should work on any machine | |
** using IEEE754 with a 32-bit integer type. | |
** | |
@@ LUA_IEEELL extends the trick to LUA_INTEGER; should only be | |
** defined when LUA_INTEGER is a 32-bit integer. | |
** | |
@@ LUA_IEEEENDIAN is the endianness of doubles in your machine | |
** (0 for little endian, 1 for big endian); if not defined, Lua will | |
** check it dynamically for LUA_IEEE754TRICK (but not for LUA_NANTRICK). | |
** | |
@@ LUA_NANTRICK controls the use of a trick to pack all types into | |
** a single double value, using NaN values to represent non-number | |
** values. The trick only works on 32-bit machines (ints and pointers | |
** are 32-bit values) with numbers represented as IEEE 754-2008 doubles | |
** with conventional endianess (12345678 or 87654321), in CPUs that do | |
** not produce signaling NaN values (all NaNs are quiet). | |
*/ | |
/* Microsoft compiler on a Pentium (32 bit) ? */ | |
#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86) /* { */ | |
#define LUA_MSASMTRICK | |
#define LUA_IEEEENDIAN 0 | |
#define LUA_NANTRICK | |
/* pentium 32 bits? */ | |
#elif defined(__i386__) || defined(__i386) || defined(__X86__) /* }{ */ | |
# 514 "./luaconf.h" | |
#define LUA_IEEE754TRICK | |
#define LUA_IEEELL | |
#define LUA_IEEEENDIAN 0 | |
#define LUA_NANTRICK | |
/* pentium 64 bits? */ | |
#elif defined(__x86_64) /* }{ */ | |
# 522 "./luaconf.h" | |
#define LUA_IEEE754TRICK | |
#define LUA_IEEEENDIAN 0 | |
#elif defined(__POWERPC__) || defined(__ppc__) /* }{ */ | |
# 527 "./luaconf.h" | |
#define LUA_IEEE754TRICK | |
#define LUA_IEEEENDIAN 1 | |
#else /* }{ */ | |
# 532 "./luaconf.h" | |
/* assume IEEE754 and a 32-bit integer type */ | |
#define LUA_IEEE754TRICK | |
#endif /* } */ | |
# 537 "./luaconf.h" | |
#endif /* } */ | |
# 539 "./luaconf.h" | |
/* }================================================================== */ | |
/* =================================================================== */ | |
/* | |
** Local configuration. You can use this space to add your redefinitions | |
** without modifying the main part of the file. | |
*/ | |
#endif | |
# 555 "./luaconf.h" | |
# 17 "./lua.h" 2 | |
#define LUA_VERSION_MAJOR "5" | |
#define LUA_VERSION_MINOR "2" | |
#define LUA_VERSION_NUM 502 | |
#define LUA_VERSION_RELEASE "3" | |
#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-2013 Lua.org, PUC-Rio" | |
#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" | |
/* mark for precompiled code ('<esc>Lua') */ | |
#define LUA_SIGNATURE "\033Lua" | |
/* option for multiple returns in 'lua_pcall' and 'lua_call' */ | |
#define LUA_MULTRET (-1) | |
/* | |
** pseudo-indices | |
*/ | |
#define LUA_REGISTRYINDEX LUAI_FIRSTPSEUDOIDX | |
#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; | |
typedef int (*lua_CFunction) (lua_State *L); | |
/* | |
** 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); | |
/* | |
** prototype for memory-allocation functions | |
*/ | |
typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); | |
/* | |
** 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; | |
/* | |
** generic extra include file | |
*/ | |
#if defined(LUA_USER_H) | |
#if 0 /* expanded by -frewrite-includes */ | |
#include LUA_USER_H | |
#endif /* expanded by -frewrite-includes */ | |
# 118 "./lua.h" | |
# 119 "./lua.h" | |
#endif | |
# 120 "./lua.h" | |
/* | |
** 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_remove) (lua_State *L, int idx); | |
LUA_API void (lua_insert) (lua_State *L, int idx); | |
LUA_API void (lua_replace) (lua_State *L, int idx); | |
LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx); | |
LUA_API int (lua_checkstack) (lua_State *L, int sz); | |
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_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 lua_Unsigned (lua_tounsignedx) (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 */ | |
#define LUA_OPSUB 1 | |
#define LUA_OPMUL 2 | |
#define LUA_OPDIV 3 | |
#define LUA_OPMOD 4 | |
#define LUA_OPPOW 5 | |
#define LUA_OPUNM 6 | |
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 void (lua_pushunsigned) (lua_State *L, lua_Unsigned n); | |
LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t l); | |
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 void (lua_getglobal) (lua_State *L, const char *var); | |
LUA_API void (lua_gettable) (lua_State *L, int idx); | |
LUA_API void (lua_getfield) (lua_State *L, int idx, const char *k); | |
LUA_API void (lua_rawget) (lua_State *L, int idx); | |
LUA_API void (lua_rawgeti) (lua_State *L, int idx, int n); | |
LUA_API void (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 void (lua_getuservalue) (lua_State *L, int idx); | |
/* | |
** set functions (stack -> Lua) | |
*/ | |
LUA_API void (lua_setglobal) (lua_State *L, const char *var); | |
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_rawset) (lua_State *L, int idx); | |
LUA_API void (lua_rawseti) (lua_State *L, int idx, int 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, int ctx, | |
lua_CFunction k); | |
#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) | |
LUA_API int (lua_getctx) (lua_State *L, int *ctx); | |
LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc, | |
int ctx, lua_CFunction 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); | |
/* | |
** coroutine functions | |
*/ | |
LUA_API int (lua_yieldk) (lua_State *L, int nresults, int ctx, | |
lua_CFunction k); | |
#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) | |
LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg); | |
LUA_API int (lua_status) (lua_State *L); | |
/* | |
** 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_GCSETMAJORINC 8 | |
#define LUA_GCISRUNNING 9 | |
#define LUA_GCGEN 10 | |
#define LUA_GCINC 11 | |
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 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_tonumber(L,i) lua_tonumberx(L,i,NULL) | |
#define lua_tointeger(L,i) lua_tointegerx(L,i,NULL) | |
#define lua_tounsigned(L,i) lua_tounsignedx(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_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1) | |
#define lua_pushglobaltable(L) \ | |
lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS) | |
#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) | |
/* | |
** {====================================================================== | |
** 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 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 int (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', 'field', 'method' */ | |
const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */ | |
const char *source; /* (S) */ | |
int 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 CallInfo *i_ci; /* active function */ | |
}; | |
/* }====================================================================== */ | |
/****************************************************************************** | |
* Copyright (C) 1994-2013 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. | |
******************************************************************************/ | |
#endif | |
# 445 "./lua.h" | |
# 27 "ltable.c" 2 | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "ldebug.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 28 "ltable.c" | |
# 1 "./ldebug.h" 1 | |
/* | |
** $Id: ldebug.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Auxiliary functions from Debug Interface module | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef ldebug_h | |
#define ldebug_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lstate.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 11 "./ldebug.h" | |
# 1 "./lstate.h" 1 | |
/* | |
** $Id: lstate.h,v 2.82.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Global State | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef lstate_h | |
#define lstate_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lua.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 10 "./lstate.h" | |
# 11 "./lstate.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lobject.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 12 "./lstate.h" | |
# 1 "./lobject.h" 1 | |
/* | |
** $Id: lobject.h,v 2.71.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Type definitions for Lua objects | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef lobject_h | |
#define lobject_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <stdarg.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 12 "./lobject.h" | |
# 13 "./lobject.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "llimits.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 15 "./lobject.h" | |
# 1 "./llimits.h" 1 | |
/* | |
** $Id: llimits.h,v 1.103.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Limits, basic types, and some other `installation-dependent' definitions | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef llimits_h | |
#define llimits_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <limits.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 11 "./llimits.h" | |
# 12 "./llimits.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <stddef.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 12 "./llimits.h" | |
# 13 "./llimits.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lua.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 15 "./llimits.h" | |
# 16 "./llimits.h" | |
typedef unsigned LUA_INT32 lu_int32; | |
typedef LUAI_UMEM lu_mem; | |
typedef LUAI_MEM l_mem; | |
/* chars used as small naturals (so that `char' is reserved for characters) */ | |
typedef unsigned char lu_byte; | |
#define MAX_SIZET ((size_t)(~(size_t)0)-2) | |
#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)-2) | |
#define MAX_LMEM ((l_mem) ((MAX_LUMEM >> 1) - 2)) | |
#define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */ | |
/* | |
** conversion of pointer to integer | |
** this is for hashing only; there is no problem if the integer | |
** cannot hold the whole pointer value | |
*/ | |
#define IntPoint(p) ((unsigned int)(lu_mem)(p)) | |
/* type to ensure maximum alignment */ | |
#if !defined(LUAI_USER_ALIGNMENT_T) | |
#define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; } | |
#endif | |
# 52 "./llimits.h" | |
typedef LUAI_USER_ALIGNMENT_T L_Umaxalign; | |
/* result of a `usual argument conversion' over lua_Number */ | |
typedef LUAI_UACNUMBER l_uacNumber; | |
/* internal assertions for in-house debugging */ | |
#if defined(lua_assert) | |
#define check_exp(c,e) (lua_assert(c), (e)) | |
/* to avoid problems with conditions too long */ | |
#define lua_longassert(c) { if (!(c)) lua_assert(0); } | |
#else | |
# 66 "./llimits.h" | |
#define lua_assert(c) ((void)0) | |
#define check_exp(c,e) (e) | |
#define lua_longassert(c) ((void)0) | |
#endif | |
# 70 "./llimits.h" | |
/* | |
** assertion for checking API calls | |
*/ | |
#if !defined(luai_apicheck) | |
#if defined(LUA_USE_APICHECK) | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <assert.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 77 "./llimits.h" | |
# 78 "./llimits.h" | |
#define luai_apicheck(L,e) assert(e) | |
#else | |
# 80 "./llimits.h" | |
#define luai_apicheck(L,e) lua_assert(e) | |
#endif | |
# 82 "./llimits.h" | |
#endif | |
# 84 "./llimits.h" | |
#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | |
#if !defined(UNUSED) | |
#define UNUSED(x) ((void)(x)) /* to avoid warnings */ | |
#endif | |
# 91 "./llimits.h" | |
#define cast(t, exp) ((t)(exp)) | |
#define cast_byte(i) cast(lu_byte, (i)) | |
#define cast_num(i) cast(lua_Number, (i)) | |
#define cast_int(i) cast(int, (i)) | |
#define cast_uchar(i) cast(unsigned char, (i)) | |
/* | |
** non-return type | |
*/ | |
#if defined(__GNUC__) | |
#define l_noret void __attribute__((noreturn)) | |
#elif defined(_MSC_VER) | |
# 107 "./llimits.h" | |
#define l_noret void __declspec(noreturn) | |
#else | |
# 109 "./llimits.h" | |
#define l_noret void | |
#endif | |
# 111 "./llimits.h" | |
/* | |
** 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 | |
# 121 "./llimits.h" | |
/* | |
** maximum number of upvalues in a closure (both C and Lua). (Value | |
** must fit in an unsigned char.) | |
*/ | |
#define MAXUPVAL UCHAR_MAX | |
/* | |
** type for virtual-machine instructions | |
** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h) | |
*/ | |
typedef lu_int32 Instruction; | |
/* maximum stack for a Lua function */ | |
#define MAXSTACK 250 | |
/* minimum size for the string table (must be power of 2) */ | |
#if !defined(MINSTRTABSIZE) | |
#define MINSTRTABSIZE 32 | |
#endif | |
# 146 "./llimits.h" | |
/* minimum size for string buffer */ | |
#if !defined(LUA_MINBUFFER) | |
#define LUA_MINBUFFER 32 | |
#endif | |
# 152 "./llimits.h" | |
#if !defined(lua_lock) | |
#define lua_lock(L) ((void) 0) | |
#define lua_unlock(L) ((void) 0) | |
#endif | |
# 158 "./llimits.h" | |
#if !defined(luai_threadyield) | |
#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | |
#endif | |
# 162 "./llimits.h" | |
/* | |
** 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 | |
# 172 "./llimits.h" | |
#if !defined(luai_userstateclose) | |
#define luai_userstateclose(L) ((void)L) | |
#endif | |
# 176 "./llimits.h" | |
#if !defined(luai_userstatethread) | |
#define luai_userstatethread(L,L1) ((void)L) | |
#endif | |
# 180 "./llimits.h" | |
#if !defined(luai_userstatefree) | |
#define luai_userstatefree(L,L1) ((void)L) | |
#endif | |
# 184 "./llimits.h" | |
#if !defined(luai_userstateresume) | |
#define luai_userstateresume(L,n) ((void)L) | |
#endif | |
# 188 "./llimits.h" | |
#if !defined(luai_userstateyield) | |
#define luai_userstateyield(L,n) ((void)L) | |
#endif | |
# 192 "./llimits.h" | |
/* | |
** lua_number2int is a macro to convert lua_Number to int. | |
** lua_number2integer is a macro to convert lua_Number to lua_Integer. | |
** lua_number2unsigned is a macro to convert a lua_Number to a lua_Unsigned. | |
** lua_unsigned2number is a macro to convert a lua_Unsigned to a lua_Number. | |
** luai_hashnum is a macro to hash a lua_Number value into an integer. | |
** The hash must be deterministic and give reasonable values for | |
** both small and large values (outside the range of integers). | |
*/ | |
#if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK) /* { */ | |
/* trick with Microsoft assembler for X86 */ | |
#define lua_number2int(i,n) __asm {__asm fld n __asm fistp i} | |
#define lua_number2integer(i,n) lua_number2int(i, n) | |
#define lua_number2unsigned(i,n) \ | |
{__int64 l; __asm {__asm fld n __asm fistp l} i = (unsigned int)l;} | |
#elif defined(LUA_IEEE754TRICK) /* }{ */ | |
# 213 "./llimits.h" | |
/* the next trick should work on any machine using IEEE754 with | |
a 32-bit int type */ | |
union luai_Cast { double l_d; LUA_INT32 l_p[2]; }; | |
#if !defined(LUA_IEEEENDIAN) /* { */ | |
#define LUAI_EXTRAIEEE \ | |
static const union luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)}; | |
#define LUA_IEEEENDIANLOC (ieeeendian.l_p[1] == 33) | |
#else | |
# 223 "./llimits.h" | |
#define LUA_IEEEENDIANLOC LUA_IEEEENDIAN | |
#define LUAI_EXTRAIEEE /* empty */ | |
#endif /* } */ | |
# 226 "./llimits.h" | |
#define lua_number2int32(i,n,t) \ | |
{ LUAI_EXTRAIEEE \ | |
volatile union luai_Cast u; u.l_d = (n) + 6755399441055744.0; \ | |
(i) = (t)u.l_p[LUA_IEEEENDIANLOC]; } | |
#define luai_hashnum(i,n) \ | |
{ volatile union luai_Cast u; u.l_d = (n) + 1.0; /* avoid -0 */ \ | |
(i) = u.l_p[0]; (i) += u.l_p[1]; } /* add double bits for his hash */ | |
#define lua_number2int(i,n) lua_number2int32(i, n, int) | |
#define lua_number2unsigned(i,n) lua_number2int32(i, n, lua_Unsigned) | |
/* the trick can be expanded to lua_Integer when it is a 32-bit value */ | |
#if defined(LUA_IEEELL) | |
#define lua_number2integer(i,n) lua_number2int32(i, n, lua_Integer) | |
#endif | |
# 243 "./llimits.h" | |
#endif /* } */ | |
# 245 "./llimits.h" | |
/* the following definitions always work, but may be slow */ | |
#if !defined(lua_number2int) | |
#define lua_number2int(i,n) ((i)=(int)(n)) | |
#endif | |
# 252 "./llimits.h" | |
#if !defined(lua_number2integer) | |
#define lua_number2integer(i,n) ((i)=(lua_Integer)(n)) | |
#endif | |
# 256 "./llimits.h" | |
#if !defined(lua_number2unsigned) /* { */ | |
/* the following definition assures proper modulo behavior */ | |
#if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT) | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <math.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 260 "./llimits.h" | |
# 261 "./llimits.h" | |
#define SUPUNSIGNED ((lua_Number)(~(lua_Unsigned)0) + 1) | |
#define lua_number2unsigned(i,n) \ | |
((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED)) | |
#else | |
# 265 "./llimits.h" | |
#define lua_number2unsigned(i,n) ((i)=(lua_Unsigned)(n)) | |
#endif | |
# 267 "./llimits.h" | |
#endif /* } */ | |
# 268 "./llimits.h" | |
#if !defined(lua_unsigned2number) | |
/* on several machines, coercion from unsigned to double is slow, | |
so it may be worth to avoid */ | |
#define lua_unsigned2number(u) \ | |
(((u) <= (lua_Unsigned)INT_MAX) ? (lua_Number)(int)(u) : (lua_Number)(u)) | |
#endif | |
# 276 "./llimits.h" | |
#if defined(ltable_c) && !defined(luai_hashnum) | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <float.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 281 "./llimits.h" | |
# 282 "./llimits.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <math.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 282 "./llimits.h" | |
# 283 "./llimits.h" | |
#define luai_hashnum(i,n) { int e; \ | |
n = l_mathop(frexp)(n, &e) * (lua_Number)(INT_MAX - DBL_MAX_EXP); \ | |
lua_number2int(i, n); i += e; } | |
#endif | |
# 289 "./llimits.h" | |
/* | |
** macro to control inclusion of some hard tests on stack reallocation | |
*/ | |
#if !defined(HARDSTACKTESTS) | |
#define condmovestack(L) ((void)0) | |
#else | |
# 298 "./llimits.h" | |
/* realloc stack keeping its size */ | |
#define condmovestack(L) luaD_reallocstack((L), (L)->stacksize) | |
#endif | |
# 301 "./llimits.h" | |
#if !defined(HARDMEMTESTS) | |
#define condchangemem(L) condmovestack(L) | |
#else | |
# 305 "./llimits.h" | |
#define condchangemem(L) \ | |
((void)(!(G(L)->gcrunning) || (luaC_fullgc(L, 0), 1))) | |
#endif | |
# 308 "./llimits.h" | |
#endif | |
# 310 "./llimits.h" | |
# 16 "./lobject.h" 2 | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lua.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 16 "./lobject.h" | |
# 17 "./lobject.h" | |
/* | |
** Extra tags for non-values | |
*/ | |
#define LUA_TPROTO LUA_NUMTAGS | |
#define LUA_TUPVAL (LUA_NUMTAGS+1) | |
#define LUA_TDEADKEY (LUA_NUMTAGS+2) | |
/* | |
** number of all possible tags (including LUA_TNONE but excluding DEADKEY) | |
*/ | |
#define LUA_TOTALTAGS (LUA_TUPVAL+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 | |
*/ | |
#define VARBITS (3 << 4) | |
/* | |
** 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 */ | |
/* Bit mark for collectable types */ | |
#define BIT_ISCOLLECTABLE (1 << 6) | |
/* mark a tag as collectable */ | |
#define ctb(t) ((t) | BIT_ISCOLLECTABLE) | |
/* | |
** Union of all collectable objects | |
*/ | |
typedef union GCObject GCObject; | |
/* | |
** Common Header for all collectable objects (in macro form, to be | |
** included in other objects) | |
*/ | |
#define CommonHeader GCObject *next; lu_byte tt; lu_byte marked | |
/* | |
** Common header in struct form | |
*/ | |
typedef struct GCheader { | |
CommonHeader; | |
} GCheader; | |
/* | |
** Union of all Lua values | |
*/ | |
typedef union Value Value; | |
#define numfield lua_Number n; /* numbers */ | |
/* | |
** Tagged Values. This is the basic representation of values in Lua, | |
** an actual value plus a tag with its type. | |
*/ | |
#define TValuefields Value value_; int tt_ | |
typedef struct lua_TValue TValue; | |
/* macro defining a nil value */ | |
#define NILCONSTANT {NULL}, LUA_TNIL | |
#define val_(o) ((o)->value_) | |
#define num_(o) (val_(o).n) | |
/* raw type tag of a TValue */ | |
#define rttype(o) ((o)->tt_) | |
/* tag with no variants (bits 0-3) */ | |
#define novariant(x) ((x) & 0x0F) | |
/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */ | |
#define ttype(o) (rttype(o) & 0x3F) | |
/* type tag of a TValue with no variants (bits 0-3) */ | |
#define ttypenv(o) (novariant(rttype(o))) | |
/* Macros to test type */ | |
#define checktag(o,t) (rttype(o) == (t)) | |
#define checktype(o,t) (ttypenv(o) == (t)) | |
#define ttisnumber(o) checktag((o), LUA_TNUMBER) | |
#define ttisnil(o) checktag((o), LUA_TNIL) | |
#define ttisboolean(o) checktag((o), LUA_TBOOLEAN) | |
#define ttislightuserdata(o) checktag((o), LUA_TLIGHTUSERDATA) | |
#define ttisstring(o) checktype((o), LUA_TSTRING) | |
#define ttisshrstring(o) checktag((o), ctb(LUA_TSHRSTR)) | |
#define ttislngstring(o) checktag((o), ctb(LUA_TLNGSTR)) | |
#define ttistable(o) checktag((o), ctb(LUA_TTABLE)) | |
#define ttisfunction(o) checktype(o, LUA_TFUNCTION) | |
#define ttisclosure(o) ((rttype(o) & 0x1F) == LUA_TFUNCTION) | |
#define ttisCclosure(o) checktag((o), ctb(LUA_TCCL)) | |
#define ttisLclosure(o) checktag((o), ctb(LUA_TLCL)) | |
#define ttislcf(o) checktag((o), LUA_TLCF) | |
#define ttisuserdata(o) checktag((o), ctb(LUA_TUSERDATA)) | |
#define ttisthread(o) checktag((o), ctb(LUA_TTHREAD)) | |
#define ttisdeadkey(o) checktag((o), LUA_TDEADKEY) | |
#define ttisequal(o1,o2) (rttype(o1) == rttype(o2)) | |
/* Macros to access values */ | |
#define nvalue(o) check_exp(ttisnumber(o), num_(o)) | |
#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | |
#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | |
#define rawtsvalue(o) check_exp(ttisstring(o), &val_(o).gc->ts) | |
#define tsvalue(o) (&rawtsvalue(o)->tsv) | |
#define rawuvalue(o) check_exp(ttisuserdata(o), &val_(o).gc->u) | |
#define uvalue(o) (&rawuvalue(o)->uv) | |
#define clvalue(o) check_exp(ttisclosure(o), &val_(o).gc->cl) | |
#define clLvalue(o) check_exp(ttisLclosure(o), &val_(o).gc->cl.l) | |
#define clCvalue(o) check_exp(ttisCclosure(o), &val_(o).gc->cl.c) | |
#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | |
#define hvalue(o) check_exp(ttistable(o), &val_(o).gc->h) | |
#define bvalue(o) check_exp(ttisboolean(o), val_(o).b) | |
#define thvalue(o) check_exp(ttisthread(o), &val_(o).gc->th) | |
/* a dead value may get the 'gc' field, but cannot access its contents */ | |
#define deadvalue(o) check_exp(ttisdeadkey(o), cast(void *, val_(o).gc)) | |
#define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0)) | |
#define iscollectable(o) (rttype(o) & BIT_ISCOLLECTABLE) | |
/* Macros for internal tests */ | |
#define righttt(obj) (ttype(obj) == gcvalue(obj)->gch.tt) | |
#define checkliveness(g,obj) \ | |
lua_longassert(!iscollectable(obj) || \ | |
(righttt(obj) && !isdead(g,gcvalue(obj)))) | |
/* Macros to set values */ | |
#define settt_(o,t) ((o)->tt_=(t)) | |
#define setnvalue(obj,x) \ | |
{ TValue *io=(obj); num_(io)=(x); settt_(io, LUA_TNUMBER); } | |
#define setnilvalue(obj) settt_(obj, LUA_TNIL) | |
#define setfvalue(obj,x) \ | |
{ TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_TLCF); } | |
#define setpvalue(obj,x) \ | |
{ TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_TLIGHTUSERDATA); } | |
#define setbvalue(obj,x) \ | |
{ TValue *io=(obj); val_(io).b=(x); settt_(io, LUA_TBOOLEAN); } | |
#define setgcovalue(L,obj,x) \ | |
{ TValue *io=(obj); GCObject *i_g=(x); \ | |
val_(io).gc=i_g; settt_(io, ctb(gch(i_g)->tt)); } | |
#define setsvalue(L,obj,x) \ | |
{ TValue *io=(obj); \ | |
TString *x_ = (x); \ | |
val_(io).gc=cast(GCObject *, x_); settt_(io, ctb(x_->tsv.tt)); \ | |
checkliveness(G(L),io); } | |
#define setuvalue(L,obj,x) \ | |
{ TValue *io=(obj); \ | |
val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TUSERDATA)); \ | |
checkliveness(G(L),io); } | |
#define setthvalue(L,obj,x) \ | |
{ TValue *io=(obj); \ | |
val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTHREAD)); \ | |
checkliveness(G(L),io); } | |
#define setclLvalue(L,obj,x) \ | |
{ TValue *io=(obj); \ | |
val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TLCL)); \ | |
checkliveness(G(L),io); } | |
#define setclCvalue(L,obj,x) \ | |
{ TValue *io=(obj); \ | |
val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TCCL)); \ | |
checkliveness(G(L),io); } | |
#define sethvalue(L,obj,x) \ | |
{ TValue *io=(obj); \ | |
val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTABLE)); \ | |
checkliveness(G(L),io); } | |
#define setdeadvalue(obj) settt_(obj, LUA_TDEADKEY) | |
#define setobj(L,obj1,obj2) \ | |
{ const TValue *io2=(obj2); TValue *io1=(obj1); \ | |
io1->value_ = io2->value_; io1->tt_ = io2->tt_; \ | |
checkliveness(G(L),io1); } | |
/* | |
** different types of assignments, according to destination | |
*/ | |
/* from stack to (same) stack */ | |
#define setobjs2s setobj | |
/* to stack (not from same stack) */ | |
#define setobj2s setobj | |
#define setsvalue2s setsvalue | |
#define sethvalue2s sethvalue | |
#define setptvalue2s setptvalue | |
/* from table to same table */ | |
#define setobjt2t setobj | |
/* to table */ | |
#define setobj2t setobj | |
/* to new object */ | |
#define setobj2n setobj | |
#define setsvalue2n setsvalue | |
/* check whether a number is valid (useful only for NaN trick) */ | |
#define luai_checknum(L,o,c) { /* empty */ } | |
/* | |
** {====================================================== | |
** NaN Trick | |
** ======================================================= | |
*/ | |
#if defined(LUA_NANTRICK) | |
/* | |
** numbers are represented in the 'd_' field. All other values have the | |
** value (NNMARK | tag) in 'tt__'. A number with such pattern would be | |
** a "signaled NaN", which is never generated by regular operations by | |
** the CPU (nor by 'strtod') | |
*/ | |
/* allows for external implementation for part of the trick */ | |
#if !defined(NNMARK) /* { */ | |
#if !defined(LUA_IEEEENDIAN) | |
#error option 'LUA_NANTRICK' needs 'LUA_IEEEENDIAN' | |
#endif | |
# 291 "./lobject.h" | |
#define NNMARK 0x7FF7A500 | |
#define NNMASK 0x7FFFFF00 | |
#undef TValuefields | |
#undef NILCONSTANT | |
#if (LUA_IEEEENDIAN == 0) /* { */ | |
/* little endian */ | |
#define TValuefields \ | |
union { struct { Value v__; int tt__; } i; double d__; } u | |
#define NILCONSTANT {{{NULL}, tag2tt(LUA_TNIL)}} | |
/* field-access macros */ | |
#define v_(o) ((o)->u.i.v__) | |
#define d_(o) ((o)->u.d__) | |
#define tt_(o) ((o)->u.i.tt__) | |
#else /* }{ */ | |
# 311 "./lobject.h" | |
/* big endian */ | |
#define TValuefields \ | |
union { struct { int tt__; Value v__; } i; double d__; } u | |
#define NILCONSTANT {{tag2tt(LUA_TNIL), {NULL}}} | |
/* field-access macros */ | |
#define v_(o) ((o)->u.i.v__) | |
#define d_(o) ((o)->u.d__) | |
#define tt_(o) ((o)->u.i.tt__) | |
#endif /* } */ | |
# 322 "./lobject.h" | |
#endif /* } */ | |
# 324 "./lobject.h" | |
/* correspondence with standard representation */ | |
#undef val_ | |
#define val_(o) v_(o) | |
#undef num_ | |
#define num_(o) d_(o) | |
#undef numfield | |
#define numfield /* no such field; numbers are the entire struct */ | |
/* basic check to distinguish numbers from non-numbers */ | |
#undef ttisnumber | |
#define ttisnumber(o) ((tt_(o) & NNMASK) != NNMARK) | |
#define tag2tt(t) (NNMARK | (t)) | |
#undef rttype | |
#define rttype(o) (ttisnumber(o) ? LUA_TNUMBER : tt_(o) & 0xff) | |
#undef settt_ | |
#define settt_(o,t) (tt_(o) = tag2tt(t)) | |
#undef setnvalue | |
#define setnvalue(obj,x) \ | |
{ TValue *io_=(obj); num_(io_)=(x); lua_assert(ttisnumber(io_)); } | |
#undef setobj | |
#define setobj(L,obj1,obj2) \ | |
{ const TValue *o2_=(obj2); TValue *o1_=(obj1); \ | |
o1_->u = o2_->u; \ | |
checkliveness(G(L),o1_); } | |
/* | |
** these redefinitions are not mandatory, but these forms are more efficient | |
*/ | |
#undef checktag | |
#undef checktype | |
#define checktag(o,t) (tt_(o) == tag2tt(t)) | |
#define checktype(o,t) (ctb(tt_(o) | VARBITS) == ctb(tag2tt(t) | VARBITS)) | |
#undef ttisequal | |
#define ttisequal(o1,o2) \ | |
(ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2))) | |
#undef luai_checknum | |
#define luai_checknum(L,o,c) { if (!ttisnumber(o)) c; } | |
#endif | |
# 377 "./lobject.h" | |
/* }====================================================== */ | |
/* | |
** {====================================================== | |
** types and prototypes | |
** ======================================================= | |
*/ | |
union Value { | |
GCObject *gc; /* collectable objects */ | |
void *p; /* light userdata */ | |
int b; /* booleans */ | |
lua_CFunction f; /* light C functions */ | |
numfield /* numbers */ | |
}; | |
struct lua_TValue { | |
TValuefields; | |
}; | |
typedef TValue *StkId; /* index to stack elements */ | |
/* | |
** Header for string value; string bytes follow the end of this structure | |
*/ | |
typedef union TString { | |
L_Umaxalign dummy; /* ensures maximum alignment for strings */ | |
struct { | |
CommonHeader; | |
lu_byte extra; /* reserved words for short strings; "has hash" for longs */ | |
unsigned int hash; | |
size_t len; /* number of characters in string */ | |
} tsv; | |
} TString; | |
/* get the actual string (array of bytes) from a TString */ | |
#define getstr(ts) cast(const char *, (ts) + 1) | |
/* get the actual string (array of bytes) from a Lua value */ | |
#define svalue(o) getstr(rawtsvalue(o)) | |
/* | |
** Header for userdata; memory area follows the end of this structure | |
*/ | |
typedef union Udata { | |
L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */ | |
struct { | |
CommonHeader; | |
struct Table *metatable; | |
struct Table *env; | |
size_t len; /* number of bytes */ | |
} uv; | |
} Udata; | |
/* | |
** Description of an upvalue for function prototypes | |
*/ | |
typedef struct Upvaldesc { | |
TString *name; /* upvalue name (for debug information) */ | |
lu_byte instack; /* whether it is in stack */ | |
lu_byte idx; /* index of upvalue (in stack or in outer function's list) */ | |
} Upvaldesc; | |
/* | |
** Description of a local variable for function prototypes | |
** (used for debug information) | |
*/ | |
typedef struct LocVar { | |
TString *varname; | |
int startpc; /* first point where variable is active */ | |
int endpc; /* first point where variable is dead */ | |
} LocVar; | |
/* | |
** Function Prototypes | |
*/ | |
typedef struct Proto { | |
CommonHeader; | |
TValue *k; /* constants used by the function */ | |
Instruction *code; | |
struct Proto **p; /* functions defined inside the function */ | |
int *lineinfo; /* map from opcodes to source lines (debug information) */ | |
LocVar *locvars; /* information about local variables (debug information) */ | |
Upvaldesc *upvalues; /* upvalue information */ | |
union Closure *cache; /* last created closure with this prototype */ | |
TString *source; /* used for debug information */ | |
int sizeupvalues; /* size of 'upvalues' */ | |
int sizek; /* size of `k' */ | |
int sizecode; | |
int sizelineinfo; | |
int sizep; /* size of `p' */ | |
int sizelocvars; | |
int linedefined; | |
int lastlinedefined; | |
GCObject *gclist; | |
lu_byte numparams; /* number of fixed parameters */ | |
lu_byte is_vararg; | |
lu_byte maxstacksize; /* maximum stack used by this function */ | |
} Proto; | |
/* | |
** Lua Upvalues | |
*/ | |
typedef struct UpVal { | |
CommonHeader; | |
TValue *v; /* points to stack or to its own value */ | |
union { | |
TValue value; /* the value (when closed) */ | |
struct { /* double linked list (when open) */ | |
struct UpVal *prev; | |
struct UpVal *next; | |
} l; | |
} u; | |
} UpVal; | |
/* | |
** Closures | |
*/ | |
#define ClosureHeader \ | |
CommonHeader; lu_byte nupvalues; GCObject *gclist | |
typedef struct CClosure { | |
ClosureHeader; | |
lua_CFunction f; | |
TValue upvalue[1]; /* list of upvalues */ | |
} CClosure; | |
typedef struct LClosure { | |
ClosureHeader; | |
struct Proto *p; | |
UpVal *upvals[1]; /* list of upvalues */ | |
} LClosure; | |
typedef union Closure { | |
CClosure c; | |
LClosure l; | |
} Closure; | |
#define isLfunction(o) ttisLclosure(o) | |
#define getproto(o) (clLvalue(o)->p) | |
/* | |
** Tables | |
*/ | |
typedef union TKey { | |
struct { | |
TValuefields; | |
struct Node *next; /* for chaining */ | |
} nk; | |
TValue tvk; | |
} TKey; | |
typedef struct Node { | |
TValue i_val; | |
TKey i_key; | |
} Node; | |
typedef struct Table { | |
CommonHeader; | |
lu_byte flags; /* 1<<p means tagmethod(p) is not present */ | |
lu_byte lsizenode; /* log2 of size of `node' array */ | |
struct Table *metatable; | |
TValue *array; /* array part */ | |
Node *node; | |
Node *lastfree; /* any free position is before this position */ | |
GCObject *gclist; | |
int sizearray; /* size of `array' array */ | |
} Table; | |
/* | |
** `module' operation for hashing (size is always a power of 2) | |
*/ | |
#define lmod(s,size) \ | |
(check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1))))) | |
#define twoto(x) (1<<(x)) | |
#define sizenode(t) (twoto((t)->lsizenode)) | |
/* | |
** (address of) a fixed nil value | |
*/ | |
#define luaO_nilobject (&luaO_nilobject_) | |
LUAI_DDEC const TValue luaO_nilobject_; | |
LUAI_FUNC int luaO_int2fb (unsigned int x); | |
LUAI_FUNC int luaO_fb2int (int x); | |
LUAI_FUNC int luaO_ceillog2 (unsigned int x); | |
LUAI_FUNC lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2); | |
LUAI_FUNC int luaO_str2d (const char *s, size_t len, lua_Number *result); | |
LUAI_FUNC int luaO_hexavalue (int c); | |
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); | |
#endif | |
# 607 "./lobject.h" | |
# 13 "./lstate.h" 2 | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "ltm.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 13 "./lstate.h" | |
# 1 "./ltm.h" 1 | |
/* | |
** $Id: ltm.h,v 2.11.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Tag methods | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef ltm_h | |
#define ltm_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lobject.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 11 "./ltm.h" | |
# 12 "./ltm.h" | |
/* | |
* WARNING: if you change the order of this enumeration, | |
* grep "ORDER TM" | |
*/ | |
typedef enum { | |
TM_INDEX, | |
TM_NEWINDEX, | |
TM_GC, | |
TM_MODE, | |
TM_LEN, | |
TM_EQ, /* last tag method with `fast' access */ | |
TM_ADD, | |
TM_SUB, | |
TM_MUL, | |
TM_DIV, | |
TM_MOD, | |
TM_POW, | |
TM_UNM, | |
TM_LT, | |
TM_LE, | |
TM_CONCAT, | |
TM_CALL, | |
TM_N /* number of elements in the enum */ | |
} TMS; | |
#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | |
((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | |
#define fasttm(l,et,e) gfasttm(G(l), et, e) | |
#define ttypename(x) luaT_typenames_[(x) + 1] | |
#define objtypename(x) ttypename(ttypenv(x)) | |
LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS]; | |
LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename); | |
LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, | |
TMS event); | |
LUAI_FUNC void luaT_init (lua_State *L); | |
#endif | |
# 58 "./ltm.h" | |
# 14 "./lstate.h" 2 | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lzio.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 14 "./lstate.h" | |
# 1 "./lzio.h" 1 | |
/* | |
** $Id: lzio.h,v 1.26.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Buffered streams | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef lzio_h | |
#define lzio_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lua.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 11 "./lzio.h" | |
# 12 "./lzio.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lmem.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 13 "./lzio.h" | |
# 1 "./lmem.h" 1 | |
/* | |
** $Id: lmem.h,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Interface to Memory Manager | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef lmem_h | |
#define lmem_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include <stddef.h> | |
#endif /* expanded by -frewrite-includes */ | |
# 11 "./lmem.h" | |
# 12 "./lmem.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "llimits.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 13 "./lmem.h" | |
# 14 "./lmem.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lua.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 14 "./lmem.h" | |
# 15 "./lmem.h" | |
/* | |
** This macro avoids the runtime division MAX_SIZET/(e), as 'e' is | |
** always constant. | |
** The macro is somewhat complex to avoid warnings: | |
** +1 avoids warnings of "comparison has constant result"; | |
** cast to 'void' avoids warnings of "value unused". | |
*/ | |
#define luaM_reallocv(L,b,on,n,e) \ | |
(cast(void, \ | |
(cast(size_t, (n)+1) > MAX_SIZET/(e)) ? (luaM_toobig(L), 0) : 0), \ | |
luaM_realloc_(L, (b), (on)*(e), (n)*(e))) | |
#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_reallocv(L, (b), n, 0, sizeof((b)[0])) | |
#define luaM_malloc(L,s) luaM_realloc_(L, NULL, 0, (s)) | |
#define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t))) | |
#define luaM_newvector(L,n,t) \ | |
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)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e))) | |
#define luaM_reallocvector(L, v,oldn,n,t) \ | |
((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t)))) | |
LUAI_FUNC l_noret luaM_toobig (lua_State *L); | |
/* not to be called directly */ | |
LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize, | |
size_t size); | |
LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size, | |
size_t size_elem, int limit, | |
const char *what); | |
#endif | |
# 57 "./lmem.h" | |
# 14 "./lzio.h" 2 | |
#define EOZ (-1) /* end of stream */ | |
typedef struct Zio ZIO; | |
#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | |
typedef struct Mbuffer { | |
char *buffer; | |
size_t n; | |
size_t buffsize; | |
} 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_resetbuffer(buff) ((buff)->n = 0) | |
#define luaZ_resizebuffer(L, buff, size) \ | |
(luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \ | |
(buff)->buffsize = size) | |
#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) | |
LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n); | |
LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, | |
void *data); | |
LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n); /* read next n bytes */ | |
/* --------- Private Part ------------------ */ | |
struct 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 (ZIO *z); | |
#endif | |
# 66 "./lzio.h" | |
# 15 "./lstate.h" 2 | |
/* | |
** Some notes about garbage-collected objects: All objects in Lua must | |
** be kept somehow accessible until being freed. | |
** | |
** Lua keeps most objects linked in list g->allgc. The link uses field | |
** 'next' of the CommonHeader. | |
** | |
** Strings are kept in several lists headed by the array g->strt.hash. | |
** | |
** Open upvalues are not subject to independent garbage collection. They | |
** are collected together with their respective threads. Lua keeps a | |
** double-linked list with all open upvalues (g->uvhead) so that it can | |
** mark objects referred by them. (They are always gray, so they must | |
** be remarked in the atomic step. Usually their contents would be marked | |
** when traversing the respective threads, but the thread may already be | |
** dead, while the upvalue is still accessible through closures.) | |
** | |
** Objects with finalizers are kept in the list g->finobj. | |
** | |
** The list g->tobefnz links all objects being finalized. | |
*/ | |
struct lua_longjmp; /* defined in ldo.c */ | |
/* extra stack space to handle TM calls and some other extras */ | |
#define EXTRA_STACK 5 | |
#define BASIC_STACK_SIZE (2*LUA_MINSTACK) | |
/* kinds of Garbage Collection */ | |
#define KGC_NORMAL 0 | |
#define KGC_EMERGENCY 1 /* gc was forced by an allocation failure */ | |
#define KGC_GEN 2 /* generational collection */ | |
typedef struct stringtable { | |
GCObject **hash; | |
lu_int32 nuse; /* number of elements */ | |
int size; | |
} stringtable; | |
/* | |
** information about a call | |
*/ | |
typedef struct CallInfo { | |
StkId func; /* function index in the stack */ | |
StkId top; /* top for this function */ | |
struct CallInfo *previous, *next; /* dynamic call link */ | |
short nresults; /* expected number of results from this function */ | |
lu_byte callstatus; | |
ptrdiff_t extra; | |
union { | |
struct { /* only for Lua functions */ | |
StkId base; /* base for this function */ | |
const Instruction *savedpc; | |
} l; | |
struct { /* only for C functions */ | |
int ctx; /* context info. in case of yields */ | |
lua_CFunction k; /* continuation in case of yields */ | |
ptrdiff_t old_errfunc; | |
lu_byte old_allowhook; | |
lu_byte status; | |
} c; | |
} u; | |
} CallInfo; | |
/* | |
** Bits in CallInfo status | |
*/ | |
#define CIST_LUA (1<<0) /* call is running a Lua function */ | |
#define CIST_HOOKED (1<<1) /* call is running a debug hook */ | |
#define CIST_REENTRY (1<<2) /* call is running on same invocation of | |
luaV_execute of previous call */ | |
#define CIST_YIELDED (1<<3) /* call reentered after suspension */ | |
#define CIST_YPCALL (1<<4) /* call is a yieldable protected call */ | |
#define CIST_STAT (1<<5) /* call has an error status (pcall) */ | |
#define CIST_TAIL (1<<6) /* call was tail called */ | |
#define CIST_HOOKYIELD (1<<7) /* last hook called yielded */ | |
#define isLua(ci) ((ci)->callstatus & CIST_LUA) | |
/* | |
** `global state', shared by all threads of this state | |
*/ | |
typedef struct global_State { | |
lua_Alloc frealloc; /* function to reallocate memory */ | |
void *ud; /* auxiliary data to `frealloc' */ | |
lu_mem totalbytes; /* number of bytes currently allocated - GCdebt */ | |
l_mem GCdebt; /* bytes allocated not yet compensated by the collector */ | |
lu_mem GCmemtrav; /* memory traversed by the GC */ | |
lu_mem GCestimate; /* an estimate of the non-garbage memory in use */ | |
stringtable strt; /* hash table for strings */ | |
TValue l_registry; | |
unsigned int seed; /* randomized seed for hashes */ | |
lu_byte currentwhite; | |
lu_byte gcstate; /* state of garbage collector */ | |
lu_byte gckind; /* kind of GC running */ | |
lu_byte gcrunning; /* true if GC is running */ | |
int sweepstrgc; /* position of sweep in `strt' */ | |
GCObject *allgc; /* list of all collectable objects */ | |
GCObject *finobj; /* list of collectable objects with finalizers */ | |
GCObject **sweepgc; /* current position of sweep in list 'allgc' */ | |
GCObject **sweepfin; /* current position of sweep in list 'finobj' */ | |
GCObject *gray; /* list of gray objects */ | |
GCObject *grayagain; /* list of objects to be traversed atomically */ | |
GCObject *weak; /* list of tables with weak values */ | |
GCObject *ephemeron; /* list of ephemeron tables (weak keys) */ | |
GCObject *allweak; /* list of all-weak tables */ | |
GCObject *tobefnz; /* list of userdata to be GC */ | |
UpVal uvhead; /* head of double-linked list of all open upvalues */ | |
Mbuffer buff; /* temporary buffer for string concatenation */ | |
int gcpause; /* size of pause between successive GCs */ | |
int gcmajorinc; /* pause between major collections (only in gen. mode) */ | |
int gcstepmul; /* GC `granularity' */ | |
lua_CFunction panic; /* to be called in unprotected errors */ | |
struct lua_State *mainthread; | |
const lua_Number *version; /* pointer to version number */ | |
TString *memerrmsg; /* memory-error message */ | |
TString *tmname[TM_N]; /* array with tag-method names */ | |
struct Table *mt[LUA_NUMTAGS]; /* metatables for basic types */ | |
} global_State; | |
/* | |
** `per thread' state | |
*/ | |
struct lua_State { | |
CommonHeader; | |
lu_byte status; | |
StkId top; /* first free slot in the stack */ | |
global_State *l_G; | |
CallInfo *ci; /* call info for current function */ | |
const Instruction *oldpc; /* last pc traced */ | |
StkId stack_last; /* last free slot in the stack */ | |
StkId stack; /* stack base */ | |
int stacksize; | |
unsigned short nny; /* number of non-yieldable calls in stack */ | |
unsigned short nCcalls; /* number of nested C calls */ | |
lu_byte hookmask; | |
lu_byte allowhook; | |
int basehookcount; | |
int hookcount; | |
lua_Hook hook; | |
GCObject *openupval; /* list of open upvalues in this stack */ | |
GCObject *gclist; | |
struct lua_longjmp *errorJmp; /* current error recover point */ | |
ptrdiff_t errfunc; /* current error handling function (stack index) */ | |
CallInfo base_ci; /* CallInfo for first level (C calling Lua) */ | |
}; | |
#define G(L) (L->l_G) | |
/* | |
** Union of all collectable objects | |
*/ | |
union GCObject { | |
GCheader gch; /* common header */ | |
union TString ts; | |
union Udata u; | |
union Closure cl; | |
struct Table h; | |
struct Proto p; | |
struct UpVal uv; | |
struct lua_State th; /* thread */ | |
}; | |
#define gch(o) (&(o)->gch) | |
/* macros to convert a GCObject into a specific value */ | |
#define rawgco2ts(o) \ | |
check_exp(novariant((o)->gch.tt) == LUA_TSTRING, &((o)->ts)) | |
#define gco2ts(o) (&rawgco2ts(o)->tsv) | |
#define rawgco2u(o) check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u)) | |
#define gco2u(o) (&rawgco2u(o)->uv) | |
#define gco2lcl(o) check_exp((o)->gch.tt == LUA_TLCL, &((o)->cl.l)) | |
#define gco2ccl(o) check_exp((o)->gch.tt == LUA_TCCL, &((o)->cl.c)) | |
#define gco2cl(o) \ | |
check_exp(novariant((o)->gch.tt) == LUA_TFUNCTION, &((o)->cl)) | |
#define gco2t(o) check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h)) | |
#define gco2p(o) check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p)) | |
#define gco2uv(o) check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv)) | |
#define gco2th(o) check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th)) | |
/* macro to convert any Lua object into a GCObject */ | |
#define obj2gco(v) (cast(GCObject *, (v))) | |
/* actual number of total bytes allocated */ | |
#define gettotalbytes(g) ((g)->totalbytes + (g)->GCdebt) | |
LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt); | |
LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1); | |
LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L); | |
LUAI_FUNC void luaE_freeCI (lua_State *L); | |
#endif | |
# 228 "./lstate.h" | |
# 12 "./ldebug.h" 2 | |
#define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1) | |
#define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : 0) | |
#define resethookcount(L) (L->hookcount = L->basehookcount) | |
/* Active Lua function (given call info) */ | |
#define ci_func(ci) (clLvalue((ci)->func)) | |
LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o, | |
const char *opname); | |
LUAI_FUNC l_noret luaG_concaterror (lua_State *L, StkId p1, StkId p2); | |
LUAI_FUNC l_noret luaG_aritherror (lua_State *L, const TValue *p1, | |
const TValue *p2); | |
LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1, | |
const TValue *p2); | |
LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...); | |
LUAI_FUNC l_noret luaG_errormsg (lua_State *L); | |
#endif | |
# 35 "./ldebug.h" | |
# 29 "ltable.c" 2 | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "ldo.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 29 "ltable.c" | |
# 1 "./ldo.h" 1 | |
/* | |
** $Id: ldo.h,v 2.20.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Stack and Call structure of Lua | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef ldo_h | |
#define ldo_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lobject.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 11 "./ldo.h" | |
# 12 "./ldo.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lstate.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 12 "./ldo.h" | |
# 13 "./ldo.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lzio.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 13 "./ldo.h" | |
# 14 "./ldo.h" | |
#define luaD_checkstack(L,n) if (L->stack_last - L->top <= (n)) \ | |
luaD_growstack(L, n); else condmovestack(L); | |
#define incr_top(L) {L->top++; luaD_checkstack(L,0);} | |
#define savestack(L,p) ((char *)(p) - (char *)L->stack) | |
#define restorestack(L,n) ((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, 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, StkId func, int nresults); | |
LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults, | |
int allowyield); | |
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, StkId firstResult); | |
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 l_noret luaD_throw (lua_State *L, int errcode); | |
LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud); | |
#endif | |
# 46 "./ldo.h" | |
# 30 "ltable.c" 2 | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lgc.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 30 "ltable.c" | |
# 1 "./lgc.h" 1 | |
/* | |
** $Id: lgc.h,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Garbage Collector | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef lgc_h | |
#define lgc_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lobject.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 11 "./lgc.h" | |
# 12 "./lgc.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lstate.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 12 "./lgc.h" | |
# 13 "./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 next GC step */ | |
#if !defined(GCSTEPSIZE) | |
/* ~100 small strings */ | |
#define GCSTEPSIZE (cast_int(100 * sizeof(TString))) | |
#endif | |
# 34 "./lgc.h" | |
/* | |
** Possible states of the Garbage Collector | |
*/ | |
#define GCSpropagate 0 | |
#define GCSatomic 1 | |
#define GCSsweepstring 2 | |
#define GCSsweepudata 3 | |
#define GCSsweep 4 | |
#define GCSpause 5 | |
#define issweepphase(g) \ | |
(GCSsweepstring <= (g)->gcstate && (g)->gcstate <= GCSsweep) | |
#define isgenerational(g) ((g)->gckind == KGC_GEN) | |
/* | |
** macros to tell when main invariant (white objects cannot point to black | |
** ones) must be kept. During a non-generational 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. During a generational collection, the | |
** invariant must be kept all times. | |
*/ | |
#define keepinvariant(g) (isgenerational(g) || g->gcstate <= GCSatomic) | |
/* | |
** Outside the collector, the state in generational mode is kept in | |
** 'propagate', so 'keepinvariant' is always true. | |
*/ | |
#define keepinvariantout(g) \ | |
check_exp(g->gcstate == GCSpropagate || !isgenerational(g), \ | |
g->gcstate <= GCSatomic) | |
/* | |
** some useful bit tricks | |
*/ | |
#define resetbits(x,m) ((x) &= cast(lu_byte, ~(m))) | |
#define setbits(x,m) ((x) |= (m)) | |
#define testbits(x,m) ((x) & (m)) | |
#define bitmask(b) (1<<(b)) | |
#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | |
#define l_setbit(x,b) setbits(x, bitmask(b)) | |
#define resetbit(x,b) resetbits(x, bitmask(b)) | |
#define testbit(x,b) testbits(x, bitmask(b)) | |
/* Layout for bit use in `marked' field: */ | |
#define WHITE0BIT 0 /* object is white (type 0) */ | |
#define WHITE1BIT 1 /* object is white (type 1) */ | |
#define BLACKBIT 2 /* object is black */ | |
#define FINALIZEDBIT 3 /* object has been separated for finalization */ | |
#define SEPARATED 4 /* object is in 'finobj' list or in 'tobefnz' */ | |
#define FIXEDBIT 5 /* object is fixed (should not be collected) */ | |
#define OLDBIT 6 /* object is old (only in generational mode) */ | |
/* bit 7 is currently used by tests (luaL_checkmemory) */ | |
#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) | |
#define iswhite(x) testbits((x)->gch.marked, WHITEBITS) | |
#define isblack(x) testbit((x)->gch.marked, BLACKBIT) | |
#define isgray(x) /* neither white nor black */ \ | |
(!testbits((x)->gch.marked, WHITEBITS | bitmask(BLACKBIT))) | |
#define isold(x) testbit((x)->gch.marked, OLDBIT) | |
/* MOVE OLD rule: whenever an object is moved to the beginning of | |
a GC list, its old bit must be cleared */ | |
#define resetoldbit(o) resetbit((o)->gch.marked, OLDBIT) | |
#define otherwhite(g) (g->currentwhite ^ WHITEBITS) | |
#define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow))) | |
#define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked) | |
#define changewhite(x) ((x)->gch.marked ^= WHITEBITS) | |
#define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT) | |
#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | |
#define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS) | |
#define luaC_condGC(L,c) \ | |
{if (G(L)->GCdebt > 0) {c;}; condchangemem(L);} | |
#define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);) | |
#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \ | |
luaC_barrier_(L,obj2gco(p),gcvalue(v)); } | |
#define luaC_barrierback(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \ | |
luaC_barrierback_(L,p); } | |
#define luaC_objbarrier(L,p,o) \ | |
{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \ | |
luaC_barrier_(L,obj2gco(p),obj2gco(o)); } | |
#define luaC_objbarrierback(L,p,o) \ | |
{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L,p); } | |
#define luaC_barrierproto(L,p,c) \ | |
{ if (isblack(obj2gco(p))) luaC_barrierproto_(L,p,c); } | |
LUAI_FUNC void luaC_freeallobjects (lua_State *L); | |
LUAI_FUNC void luaC_step (lua_State *L); | |
LUAI_FUNC void luaC_forcestep (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 GCObject *luaC_newobj (lua_State *L, int tt, size_t sz, | |
GCObject **list, int offset); | |
LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v); | |
LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o); | |
LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c); | |
LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt); | |
LUAI_FUNC void luaC_checkupvalcolor (global_State *g, UpVal *uv); | |
LUAI_FUNC void luaC_changemode (lua_State *L, int mode); | |
#endif | |
# 158 "./lgc.h" | |
# 31 "ltable.c" 2 | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lmem.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 31 "ltable.c" | |
# 32 "ltable.c" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lobject.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 32 "ltable.c" | |
# 33 "ltable.c" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lstate.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 33 "ltable.c" | |
# 34 "ltable.c" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lstring.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 34 "ltable.c" | |
# 1 "./lstring.h" 1 | |
/* | |
** $Id: lstring.h,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** String table (keep all strings handled by Lua) | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef lstring_h | |
#define lstring_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lgc.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 10 "./lstring.h" | |
# 11 "./lstring.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lobject.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 11 "./lstring.h" | |
# 12 "./lstring.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lstate.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 12 "./lstring.h" | |
# 13 "./lstring.h" | |
#define sizestring(s) (sizeof(union TString)+((s)->len+1)*sizeof(char)) | |
#define sizeudata(u) (sizeof(union Udata)+(u)->len) | |
#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | |
(sizeof(s)/sizeof(char))-1)) | |
#define luaS_fix(s) l_setbit((s)->tsv.marked, FIXEDBIT) | |
/* | |
** test whether a string is a reserved word | |
*/ | |
#define isreserved(s) ((s)->tsv.tt == LUA_TSHRSTR && (s)->tsv.extra > 0) | |
/* | |
** equality for short strings, which are always internalized | |
*/ | |
#define eqshrstr(a,b) check_exp((a)->tsv.tt == LUA_TSHRSTR, (a) == (b)) | |
LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed); | |
LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b); | |
LUAI_FUNC int luaS_eqstr (TString *a, TString *b); | |
LUAI_FUNC void luaS_resize (lua_State *L, int newsize); | |
LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e); | |
LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l); | |
LUAI_FUNC TString *luaS_new (lua_State *L, const char *str); | |
#endif | |
# 47 "./lstring.h" | |
# 35 "ltable.c" 2 | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "ltable.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 35 "ltable.c" | |
# 1 "./ltable.h" 1 | |
/* | |
** $Id: ltable.h,v 2.16.1.2 2013/08/30 15:49:41 roberto Exp $ | |
** Lua tables (hash) | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef ltable_h | |
#define ltable_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lobject.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 10 "./ltable.h" | |
# 11 "./ltable.h" | |
#define gnode(t,i) (&(t)->node[i]) | |
#define gkey(n) (&(n)->i_key.tvk) | |
#define gval(n) (&(n)->i_val) | |
#define gnext(n) ((n)->i_key.nk.next) | |
#define invalidateTMcache(t) ((t)->flags = 0) | |
/* returns the key, given the value of a table entry */ | |
#define keyfromval(v) \ | |
(gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val)))) | |
LUAI_FUNC const TValue *luaH_getint (Table *t, int key); | |
LUAI_FUNC void luaH_setint (lua_State *L, Table *t, int key, TValue *value); | |
LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key); | |
LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key); | |
LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key); | |
LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key); | |
LUAI_FUNC Table *luaH_new (lua_State *L); | |
LUAI_FUNC void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize); | |
LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize); | |
LUAI_FUNC void luaH_free (lua_State *L, Table *t); | |
LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key); | |
LUAI_FUNC int luaH_getn (Table *t); | |
#if defined(LUA_DEBUG) | |
LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key); | |
LUAI_FUNC int luaH_isdummy (Node *n); | |
#endif | |
# 43 "./ltable.h" | |
#endif | |
# 46 "./ltable.h" | |
# 36 "ltable.c" 2 | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lvm.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 36 "ltable.c" | |
# 1 "./lvm.h" 1 | |
/* | |
** $Id: lvm.h,v 2.18.1.1 2013/04/12 18:48:47 roberto Exp $ | |
** Lua virtual machine | |
** See Copyright Notice in lua.h | |
*/ | |
#ifndef lvm_h | |
#define lvm_h | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "ldo.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 11 "./lvm.h" | |
# 12 "./lvm.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "lobject.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 12 "./lvm.h" | |
# 13 "./lvm.h" | |
#if 0 /* expanded by -frewrite-includes */ | |
#include "ltm.h" | |
#endif /* expanded by -frewrite-includes */ | |
# 13 "./lvm.h" | |
# 14 "./lvm.h" | |
#define tostring(L,o) (ttisstring(o) || (luaV_tostring(L, o))) | |
#define tonumber(o,n) (ttisnumber(o) || (((o) = luaV_tonumber(o,n)) != NULL)) | |
#define equalobj(L,o1,o2) (ttisequal(o1, o2) && luaV_equalobj_(L, o1, o2)) | |
#define luaV_rawequalobj(o1,o2) equalobj(NULL,o1,o2) | |
/* not to called directly */ | |
LUAI_FUNC int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2); | |
LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r); | |
LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r); | |
LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n); | |
LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj); | |
LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key, | |
StkId val); | |
LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key, | |
StkId val); | |
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 void luaV_arith (lua_State *L, StkId ra, const TValue *rb, | |
const TValue *rc, TMS op); | |
LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb); | |
#endif | |
# 45 "./lvm.h" | |
# 37 "ltable.c" 2 | |
/* | |
** max size of array part is 2^MAXBITS | |
*/ | |
#if LUAI_BITSINT >= 32 | |
#define MAXBITS 30 | |
#else | |
# 45 "ltable.c" | |
#define MAXBITS (LUAI_BITSINT-2) | |
#endif | |
# 47 "ltable.c" | |
#define MAXASIZE (1 << MAXBITS) | |
#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | |
#define hashstr(t,str) hashpow2(t, (str)->tsv.hash) | |
#define hashboolean(t,p) hashpow2(t, p) | |
/* | |
** for some types, it is better to avoid modulus by power of 2, as | |
** they tend to have many 2 factors. | |
*/ | |
#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | |
#define hashpointer(t,p) hashmod(t, IntPoint(p)) | |
#define dummynode (&dummynode_) | |
#define isdummy(n) ((n) == dummynode) | |
static const Node dummynode_ = { | |
{NILCONSTANT}, /* value */ | |
{{NILCONSTANT, NULL}} /* key */ | |
}; | |
/* | |
** hash for lua_Numbers | |
*/ | |
static Node *hashnum (const Table *t, lua_Number n) { | |
int i; | |
luai_hashnum(i, n); | |
if (i < 0) { | |
if (cast(unsigned int, i) == 0u - i) /* use unsigned to avoid overflows */ | |
i = 0; /* handle INT_MIN */ | |
i = -i; /* must be a positive value */ | |
} | |
return hashmod(t, i); | |
} | |
/* | |
** returns the `main' position of an element in a table (that is, the index | |
** of its hash value) | |
*/ | |
static Node *mainposition (const Table *t, const TValue *key) { | |
switch (ttype(key)) { | |
case LUA_TNUMBER: | |
return hashnum(t, nvalue(key)); | |
case LUA_TLNGSTR: { | |
TString *s = rawtsvalue(key); | |
if (s->tsv.extra == 0) { /* no hash? */ | |
s->tsv.hash = luaS_hash(getstr(s), s->tsv.len, s->tsv.hash); | |
s->tsv.extra = 1; /* now it has its hash */ | |
} | |
return hashstr(t, rawtsvalue(key)); | |
} | |
case LUA_TSHRSTR: | |
return hashstr(t, rawtsvalue(key)); | |
case LUA_TBOOLEAN: | |
return hashboolean(t, bvalue(key)); | |
case LUA_TLIGHTUSERDATA: | |
return hashpointer(t, pvalue(key)); | |
case LUA_TLCF: | |
return hashpointer(t, fvalue(key)); | |
default: | |
return hashpointer(t, gcvalue(key)); | |
} | |
} | |
/* | |
** returns the index for `key' if `key' is an appropriate key to live in | |
** the array part of the table, -1 otherwise. | |
*/ | |
static int arrayindex (const TValue *key) { | |
if (ttisnumber(key)) { | |
lua_Number n = nvalue(key); | |
int k; | |
lua_number2int(k, n); | |
if (luai_numeq(cast_num(k), n)) | |
return k; | |
} | |
return -1; /* `key' did not match some condition */ | |
} | |
/* | |
** returns the index of a `key' for table traversals. First goes all | |
** elements in the array part, then elements in the hash part. The | |
** beginning of a traversal is signaled by -1. | |
*/ | |
static int findindex (lua_State *L, Table *t, StkId key) { | |
int i; | |
if (ttisnil(key)) return -1; /* first iteration */ | |
i = arrayindex(key); | |
if (0 < i && i <= t->sizearray) /* is `key' inside array part? */ | |
return i-1; /* yes; that's the index (corrected to C) */ | |
else { | |
Node *n = mainposition(t, key); | |
for (;;) { /* check whether `key' is somewhere in the chain */ | |
/* key may be dead already, but it is ok to use it in `next' */ | |
if (luaV_rawequalobj(gkey(n), key) || | |
(ttisdeadkey(gkey(n)) && iscollectable(key) && | |
deadvalue(gkey(n)) == gcvalue(key))) { | |
i = cast_int(n - gnode(t, 0)); /* key index in hash table */ | |
/* hash elements are numbered after array ones */ | |
return i + t->sizearray; | |
} | |
else n = gnext(n); | |
if (n == NULL) | |
luaG_runerror(L, "invalid key to " LUA_QL("next")); /* key not found */ | |
} | |
} | |
} | |
int luaH_next (lua_State *L, Table *t, StkId key) { | |
int i = findindex(L, t, key); /* find original element */ | |
for (i++; i < t->sizearray; i++) { /* try first array part */ | |
if (!ttisnil(&t->array[i])) { /* a non-nil value? */ | |
setnvalue(key, cast_num(i+1)); | |
setobj2s(L, key+1, &t->array[i]); | |
return 1; | |
} | |
} | |
for (i -= t->sizearray; i < sizenode(t); i++) { /* then hash part */ | |
if (!ttisnil(gval(gnode(t, i)))) { /* a non-nil value? */ | |
setobj2s(L, key, gkey(gnode(t, i))); | |
setobj2s(L, key+1, gval(gnode(t, i))); | |
return 1; | |
} | |
} | |
return 0; /* no more elements */ | |
} | |
/* | |
** {============================================================= | |
** Rehash | |
** ============================================================== | |
*/ | |
static int computesizes (int nums[], int *narray) { | |
int i; | |
int twotoi; /* 2^i */ | |
int a = 0; /* number of elements smaller than 2^i */ | |
int na = 0; /* number of elements to go to array part */ | |
int n = 0; /* optimal size for array part */ | |
for (i = 0, twotoi = 1; twotoi/2 < *narray; i++, twotoi *= 2) { | |
if (nums[i] > 0) { | |
a += nums[i]; | |
if (a > twotoi/2) { /* more than half elements present? */ | |
n = twotoi; /* optimal size (till now) */ | |
na = a; /* all elements smaller than n will go to array part */ | |
} | |
} | |
if (a == *narray) break; /* all elements already counted */ | |
} | |
*narray = n; | |
lua_assert(*narray/2 <= na && na <= *narray); | |
return na; | |
} | |
static int countint (const TValue *key, int *nums) { | |
int k = arrayindex(key); | |
if (0 < k && k <= MAXASIZE) { /* is `key' an appropriate array index? */ | |
nums[luaO_ceillog2(k)]++; /* count as such */ | |
return 1; | |
} | |
else | |
return 0; | |
} | |
static int numusearray (const Table *t, int *nums) { | |
int lg; | |
int ttlg; /* 2^lg */ | |
int ause = 0; /* summation of `nums' */ | |
int i = 1; /* count to traverse all array keys */ | |
for (lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg*=2) { /* for each slice */ | |
int lc = 0; /* counter */ | |
int lim = ttlg; | |
if (lim > t->sizearray) { | |
lim = t->sizearray; /* adjust upper limit */ | |
if (i > lim) | |
break; /* no more elements to count */ | |
} | |
/* count elements in range (2^(lg-1), 2^lg] */ | |
for (; i <= lim; i++) { | |
if (!ttisnil(&t->array[i-1])) | |
lc++; | |
} | |
nums[lg] += lc; | |
ause += lc; | |
} | |
return ause; | |
} | |
static int numusehash (const Table *t, int *nums, int *pnasize) { | |
int totaluse = 0; /* total number of elements */ | |
int ause = 0; /* summation of `nums' */ | |
int i = sizenode(t); | |
while (i--) { | |
Node *n = &t->node[i]; | |
if (!ttisnil(gval(n))) { | |
ause += countint(gkey(n), nums); | |
totaluse++; | |
} | |
} | |
*pnasize += ause; | |
return totaluse; | |
} | |
static void setarrayvector (lua_State *L, Table *t, int size) { | |
int i; | |
luaM_reallocvector(L, t->array, t->sizearray, size, TValue); | |
for (i=t->sizearray; i<size; i++) | |
setnilvalue(&t->array[i]); | |
t->sizearray = size; | |
} | |
static void setnodevector (lua_State *L, Table *t, int size) { | |
int lsize; | |
if (size == 0) { /* no elements to hash part? */ | |
t->node = cast(Node *, dummynode); /* use common `dummynode' */ | |
lsize = 0; | |
} | |
else { | |
int i; | |
lsize = luaO_ceillog2(size); | |
if (lsize > MAXBITS) | |
luaG_runerror(L, "table overflow"); | |
size = twoto(lsize); | |
t->node = luaM_newvector(L, size, Node); | |
for (i=0; i<size; i++) { | |
Node *n = gnode(t, i); | |
gnext(n) = NULL; | |
setnilvalue(gkey(n)); | |
setnilvalue(gval(n)); | |
} | |
} | |
t->lsizenode = cast_byte(lsize); | |
t->lastfree = gnode(t, size); /* all positions are free */ | |
} | |
void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize) { | |
int i; | |
int oldasize = t->sizearray; | |
int oldhsize = t->lsizenode; | |
Node *nold = t->node; /* save old hash ... */ | |
if (nasize > oldasize) /* array part must grow? */ | |
setarrayvector(L, t, nasize); | |
/* create new hash part with appropriate size */ | |
setnodevector(L, t, nhsize); | |
if (nasize < oldasize) { /* array part must shrink? */ | |
t->sizearray = nasize; | |
/* re-insert elements from vanishing slice */ | |
for (i=nasize; i<oldasize; i++) { | |
if (!ttisnil(&t->array[i])) | |
luaH_setint(L, t, i + 1, &t->array[i]); | |
} | |
/* shrink array */ | |
luaM_reallocvector(L, t->array, oldasize, nasize, TValue); | |
} | |
/* re-insert elements from hash part */ | |
for (i = twoto(oldhsize) - 1; i >= 0; i--) { | |
Node *old = nold+i; | |
if (!ttisnil(gval(old))) { | |
/* doesn't need barrier/invalidate cache, as entry was | |
already present in the table */ | |
setobjt2t(L, luaH_set(L, t, gkey(old)), gval(old)); | |
} | |
} | |
if (!isdummy(nold)) | |
luaM_freearray(L, nold, cast(size_t, twoto(oldhsize))); /* free old array */ | |
} | |
void luaH_resizearray (lua_State *L, Table *t, int nasize) { | |
int nsize = isdummy(t->node) ? 0 : sizenode(t); | |
luaH_resize(L, t, nasize, nsize); | |
} | |
static void rehash (lua_State *L, Table *t, const TValue *ek) { | |
int nasize, na; | |
int nums[MAXBITS+1]; /* nums[i] = number of keys with 2^(i-1) < k <= 2^i */ | |
int i; | |
int totaluse; | |
for (i=0; i<=MAXBITS; i++) nums[i] = 0; /* reset counts */ | |
nasize = numusearray(t, nums); /* count keys in array part */ | |
totaluse = nasize; /* all those keys are integer keys */ | |
totaluse += numusehash(t, nums, &nasize); /* count keys in hash part */ | |
/* count extra key */ | |
nasize += countint(ek, nums); | |
totaluse++; | |
/* compute new size for array part */ | |
na = computesizes(nums, &nasize); | |
/* resize the table to new computed sizes */ | |
luaH_resize(L, t, nasize, totaluse - na); | |
} | |
/* | |
** }============================================================= | |
*/ | |
Table *luaH_new (lua_State *L) { | |
Table *t = &luaC_newobj(L, LUA_TTABLE, sizeof(Table), NULL, 0)->h; | |
t->metatable = NULL; | |
t->flags = cast_byte(~0); | |
t->array = NULL; | |
t->sizearray = 0; | |
setnodevector(L, t, 0); | |
return t; | |
} | |
void luaH_free (lua_State *L, Table *t) { | |
if (!isdummy(t->node)) | |
luaM_freearray(L, t->node, cast(size_t, sizenode(t))); | |
luaM_freearray(L, t->array, t->sizearray); | |
luaM_free(L, t); | |
} | |
static Node *getfreepos (Table *t) { | |
while (t->lastfree > t->node) { | |
t->lastfree--; | |
if (ttisnil(gkey(t->lastfree))) | |
return t->lastfree; | |
} | |
return NULL; /* could not find a free place */ | |
} | |
/* | |
** inserts a new key into a hash table; first, check whether key's main | |
** position is free. If not, check whether colliding node is in its main | |
** position or not: if it is not, move colliding node to an empty place and | |
** put new key in its main position; otherwise (colliding node is in its main | |
** position), new key goes to an empty position. | |
*/ | |
TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) { | |
Node *mp; | |
if (ttisnil(key)) luaG_runerror(L, "table index is nil"); | |
else if (ttisnumber(key) && luai_numisnan(L, nvalue(key))) | |
luaG_runerror(L, "table index is NaN"); | |
mp = mainposition(t, key); | |
if (!ttisnil(gval(mp)) || isdummy(mp)) { /* main position is taken? */ | |
Node *othern; | |
Node *n = getfreepos(t); /* get a free place */ | |
if (n == NULL) { /* cannot find a free place? */ | |
rehash(L, t, key); /* grow table */ | |
/* whatever called 'newkey' take care of TM cache and GC barrier */ | |
return luaH_set(L, t, key); /* insert key into grown table */ | |
} | |
lua_assert(!isdummy(n)); | |
othern = mainposition(t, gkey(mp)); | |
if (othern != mp) { /* is colliding node out of its main position? */ | |
/* yes; move colliding node into free position */ | |
while (gnext(othern) != mp) othern = gnext(othern); /* find previous */ | |
gnext(othern) = n; /* redo the chain with `n' in place of `mp' */ | |
*n = *mp; /* copy colliding node into free pos. (mp->next also goes) */ | |
gnext(mp) = NULL; /* now `mp' is free */ | |
setnilvalue(gval(mp)); | |
} | |
else { /* colliding node is in its own main position */ | |
/* new node will go into free position */ | |
gnext(n) = gnext(mp); /* chain new position */ | |
gnext(mp) = n; | |
mp = n; | |
} | |
} | |
setobj2t(L, gkey(mp), key); | |
luaC_barrierback(L, obj2gco(t), key); | |
lua_assert(ttisnil(gval(mp))); | |
return gval(mp); | |
} | |
/* | |
** search function for integers | |
*/ | |
const TValue *luaH_getint (Table *t, int key) { | |
/* (1 <= key && key <= t->sizearray) */ | |
if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray)) | |
return &t->array[key-1]; | |
else { | |
lua_Number nk = cast_num(key); | |
Node *n = hashnum(t, nk); | |
do { /* check whether `key' is somewhere in the chain */ | |
if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk)) | |
return gval(n); /* that's it */ | |
else n = gnext(n); | |
} while (n); | |
return luaO_nilobject; | |
} | |
} | |
/* | |
** search function for short strings | |
*/ | |
const TValue *luaH_getstr (Table *t, TString *key) { | |
Node *n = hashstr(t, key); | |
lua_assert(key->tsv.tt == LUA_TSHRSTR); | |
do { /* check whether `key' is somewhere in the chain */ | |
if (ttisshrstring(gkey(n)) && eqshrstr(rawtsvalue(gkey(n)), key)) | |
return gval(n); /* that's it */ | |
else n = gnext(n); | |
} while (n); | |
return luaO_nilobject; | |
} | |
/* | |
** main search function | |
*/ | |
const TValue *luaH_get (Table *t, const TValue *key) { | |
switch (ttype(key)) { | |
case LUA_TSHRSTR: return luaH_getstr(t, rawtsvalue(key)); | |
case LUA_TNIL: return luaO_nilobject; | |
case LUA_TNUMBER: { | |
int k; | |
lua_Number n = nvalue(key); | |
lua_number2int(k, n); | |
if (luai_numeq(cast_num(k), n)) /* index is int? */ | |
return luaH_getint(t, k); /* use specialized version */ | |
/* else go through */ | |
} | |
default: { | |
Node *n = mainposition(t, key); | |
do { /* check whether `key' is somewhere in the chain */ | |
if (luaV_rawequalobj(gkey(n), key)) | |
return gval(n); /* that's it */ | |
else n = gnext(n); | |
} while (n); | |
return luaO_nilobject; | |
} | |
} | |
} | |
/* | |
** beware: when using this function you probably need to check a GC | |
** barrier and invalidate the TM cache. | |
*/ | |
TValue *luaH_set (lua_State *L, Table *t, const TValue *key) { | |
const TValue *p = luaH_get(t, key); | |
if (p != luaO_nilobject) | |
return cast(TValue *, p); | |
else return luaH_newkey(L, t, key); | |
} | |
void luaH_setint (lua_State *L, Table *t, int key, TValue *value) { | |
const TValue *p = luaH_getint(t, key); | |
TValue *cell; | |
if (p != luaO_nilobject) | |
cell = cast(TValue *, p); | |
else { | |
TValue k; | |
setnvalue(&k, cast_num(key)); | |
cell = luaH_newkey(L, t, &k); | |
} | |
setobj2t(L, cell, value); | |
} | |
static int unbound_search (Table *t, unsigned int j) { | |
unsigned int i = j; /* i is zero or a present index */ | |
j++; | |
/* find `i' and `j' such that i is present and j is not */ | |
while (!ttisnil(luaH_getint(t, j))) { | |
i = j; | |
j *= 2; | |
if (j > cast(unsigned int, MAX_INT)) { /* overflow? */ | |
/* table was built with bad purposes: resort to linear search */ | |
i = 1; | |
while (!ttisnil(luaH_getint(t, i))) i++; | |
return i - 1; | |
} | |
} | |
/* now do a binary search between them */ | |
while (j - i > 1) { | |
unsigned int m = (i+j)/2; | |
if (ttisnil(luaH_getint(t, m))) j = m; | |
else i = m; | |
} | |
return i; | |
} | |
/* | |
** Try to find a boundary in table `t'. A `boundary' is an integer index | |
** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil). | |
*/ | |
int luaH_getn (Table *t) { | |
unsigned int j = t->sizearray; | |
if (j > 0 && ttisnil(&t->array[j - 1])) { | |
/* there is a boundary in the array part: (binary) search for it */ | |
unsigned int i = 0; | |
while (j - i > 1) { | |
unsigned int m = (i+j)/2; | |
if (ttisnil(&t->array[m - 1])) j = m; | |
else i = m; | |
} | |
return i; | |
} | |
/* else must find a boundary in hash part */ | |
else if (isdummy(t->node)) /* hash part is empty? */ | |
return j; /* that is easy... */ | |
else return unbound_search(t, j); | |
} | |
#if defined(LUA_DEBUG) | |
Node *luaH_mainposition (const Table *t, const TValue *key) { | |
return mainposition(t, key); | |
} | |
int luaH_isdummy (Node *n) { return isdummy(n); } | |
#endif | |
# 587 "ltable.c" |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment