├── test.lua
├── lua52
    ├── lua.hpp
    ├── lclib.h
    ├── lapi.h
    ├── lundump.h
    ├── lfunc.h
    ├── ldebug.h
    ├── lualib.h
    ├── ltm.h
    ├── lstring.h
    ├── ltable.h
    ├── lvm.h
    ├── ldo.h
    ├── lzio.h
    ├── lzio.c
    ├── linit.c
    ├── lmem.h
    ├── ltm.c
    ├── lctype.h
    ├── llex.h
    ├── lctype.c
    ├── lmem.c
    ├── lcode.h
    ├── lopcodes.c
    ├── lparser.h
    ├── ldump.c
    ├── lcorolib.c
    ├── lfunc.c
    ├── lbitlib.c
    └── lstring.c
├── lua53
    ├── lua.hpp
    ├── lclib.h
    ├── lapi.h
    ├── lundump.h
    ├── lprefix.h
    ├── lualib.h
    ├── ldebug.h
    ├── lstring.h
    ├── lzio.c
    ├── lzio.h
    ├── lfunc.h
    ├── linit.c
    ├── ltm.h
    ├── lctype.h
    ├── ldo.h
    ├── ltable.h
    ├── lctype.c
    ├── llex.h
    ├── lmem.h
    ├── lmem.c
    ├── lcode.h
    ├── lopcodes.c
    ├── lvm.h
    ├── lfunc.c
    ├── lcorolib.c
    ├── lparser.h
    ├── lgc.h
    ├── ltm.c
    └── ldump.c
├── lua51
    ├── lapi.h
    ├── lclib.h
    ├── linit.c
    ├── lstring.h
    ├── lundump.h
    ├── ldebug.h
    ├── ltm.h
    ├── lualib.h
    ├── lfunc.h
    ├── lvm.h
    ├── ltable.h
    ├── lmem.h
    ├── lzio.h
    ├── ltm.c
    ├── lzio.c
    ├── ldo.h
    ├── llex.h
    ├── lmem.c
    ├── lparser.h
    ├── llimits.h
    ├── lcode.h
    ├── lopcodes.c
    ├── lstring.c
    ├── lgc.h
    ├── ldump.c
    ├── lfunc.c
    ├── luac.c
    └── lundump.c
├── .gitignore
├── lclib.lua
├── lconvert.h
├── convert.cpp
├── LICENSE
├── readme.md
└── premake5.lua


/test.lua:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zentelfong/LuaChinese/HEAD/test.lua


--------------------------------------------------------------------------------
/lua52/lua.hpp:
--------------------------------------------------------------------------------
 1 | // lua.hpp
 2 | // Lua header files for C++
 3 | // <<extern "C">> not supplied automatically because Lua also compiles as C++
 4 | 
 5 | extern "C" {
 6 | #include "lua.h"
 7 | #include "lualib.h"
 8 | #include "lauxlib.h"
 9 | }
10 | 


--------------------------------------------------------------------------------
/lua53/lua.hpp:
--------------------------------------------------------------------------------
 1 | // lua.hpp
 2 | // Lua header files for C++
 3 | // <<extern "C">> not supplied automatically because Lua also compiles as C++
 4 | 
 5 | extern "C" {
 6 | #include "lua.h"
 7 | #include "lualib.h"
 8 | #include "lauxlib.h"
 9 | }
10 | 


--------------------------------------------------------------------------------
/lua51/lapi.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lapi.h,v 2.2.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Auxiliary functions from Lua API
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lapi_h
 8 | #define lapi_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | 
13 | 
14 | LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o);
15 | 
16 | #endif
17 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Compiled Object files
 5 | *.slo
 6 | *.lo
 7 | *.o
 8 | *.obj
 9 | 
10 | # Precompiled Headers
11 | *.gch
12 | *.pch
13 | 
14 | # Compiled Dynamic libraries
15 | *.so
16 | *.dylib
17 | *.dll
18 | 
19 | # Fortran module files
20 | *.mod
21 | *.smod
22 | 
23 | # Compiled Static libraries
24 | *.lai
25 | *.la
26 | *.a
27 | *.lib
28 | 
29 | # Executables
30 | *.exe
31 | *.out
32 | *.app
33 | 
34 | build/


--------------------------------------------------------------------------------
/lclib.lua:
--------------------------------------------------------------------------------
 1 | 
 2 | --os
 3 | 系统={
 4 | 时钟 = os.clock,
 5 | 时间 = os.time,
 6 | 日期 = os.date,
 7 | 运行 = os.execute,
 8 | 退出 = os.exit,
 9 | 获取环境 = os.getenv,
10 | }
11 | 
12 | --match
13 | 数学={
14 | 绝对值 = math.abs,
15 | 
16 | }
17 | 
18 | --table
19 | 表={
20 | 连接 = table.concat,
21 | 插入 = table.insert,
22 | 最大索引 = table.maxn,
23 | 移除 = table.remove,
24 | 排序 = table.sort
25 | }
26 | 
27 | --string
28 | 字符串={
29 | 字节=string.byte,
30 | 字符=string.char,
31 | 
32 | }
33 | 
34 | 


--------------------------------------------------------------------------------
/lconvert.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | #include <vector>
 4 | #include <map>
 5 | 
 6 | #ifdef UNICODE
 7 | #define T(x) L##x
 8 | #define TCHAR wchar_t
 9 | #else
10 | #define T(x) x
11 | #define TCHAR char
12 | #endif
13 | 
14 | 
15 | //标识符转换器
16 | class LConvert
17 | {
18 | public:
19 | 	LConvert();
20 | 	~LConvert();
21 | 
22 | 	bool Convert(const char* in, std::string& out);
23 | 
24 | private:
25 | 	typedef std::map<std::string, std::string> map_t;
26 | 	map_t m_keyWords;
27 | };
28 | 
29 | 
30 | 
31 | 


--------------------------------------------------------------------------------
/lua51/lclib.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #ifdef __cplusplus
 4 | extern "C"
 5 | {
 6 | #endif
 7 | 
 8 | #include <lua.h>
 9 | #include <lauxlib.h>
10 | 
11 | LUALIB_API int luaC_loadfile(lua_State *L, const char *filename);
12 | LUALIB_API int luaC_loadbuffer(lua_State *L, const char *buff, size_t sz,
13 | 	const char *name);
14 | LUALIB_API int luaC_loadstring(lua_State *L, const char *s);
15 | 
16 | LUALIB_API int luaC_load(lua_State *L);
17 | 
18 | LUALIB_API void luaC_openlib(lua_State *L);
19 | 
20 | #ifdef __cplusplus
21 | }
22 | #endif
23 | 


--------------------------------------------------------------------------------
/lua52/lclib.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #ifdef __cplusplus
 4 | extern "C"
 5 | {
 6 | #endif
 7 | 
 8 | #include "lua.h"
 9 | #include "lauxlib.h"
10 | 
11 | LUALIB_API int luaC_loadfilex(lua_State *L, const char *filename,
12 | 	const char *mode);
13 | 
14 | LUALIB_API int luaC_loadbuffer(lua_State *L, const char *buff, size_t sz,
15 | 	const char *name);
16 | 
17 | LUALIB_API int luaC_loadstring(lua_State *L, const char *s);
18 | 
19 | LUALIB_API int luaC_load(lua_State *L);
20 | 
21 | LUALIB_API void luaC_openlib(lua_State *L);
22 | 
23 | #define luaC_loadfile(L,f)	luaC_loadfilex(L,f,NULL)
24 | 
25 | #ifdef __cplusplus
26 | }
27 | #endif
28 | 


--------------------------------------------------------------------------------
/lua53/lclib.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #ifdef __cplusplus
 4 | extern "C"
 5 | {
 6 | #endif
 7 | 
 8 | #include "lua.h"
 9 | #include "lauxlib.h"
10 | 
11 | LUALIB_API int luaC_loadfilex(lua_State *L, const char *filename,
12 | 	const char *mode);
13 | 
14 | LUALIB_API int luaC_loadbuffer(lua_State *L, const char *buff, size_t sz,
15 | 	const char *name);
16 | 
17 | LUALIB_API int luaC_loadstring(lua_State *L, const char *s);
18 | 
19 | LUALIB_API int luaC_load(lua_State *L);
20 | 
21 | LUALIB_API void luaC_openlib(lua_State *L);
22 | 
23 | #define luaC_loadfile(L,f)	luaC_loadfilex(L,f,NULL)
24 | 
25 | #ifdef __cplusplus
26 | }
27 | #endif
28 | 


--------------------------------------------------------------------------------
/lua52/lapi.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lapi.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Auxiliary functions from Lua API
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lapi_h
 8 | #define lapi_h
 9 | 
10 | 
11 | #include "llimits.h"
12 | #include "lstate.h"
13 | 
14 | #define api_incr_top(L)   {L->top++; api_check(L, L->top <= L->ci->top, \
15 | 				"stack overflow");}
16 | 
17 | #define adjustresults(L,nres) \
18 |     { if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }
19 | 
20 | #define api_checknelems(L,n)	api_check(L, (n) < (L->top - L->ci->func), \
21 | 				  "not enough elements in the stack")
22 | 
23 | 
24 | #endif
25 | 


--------------------------------------------------------------------------------
/lua53/lapi.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lapi.h,v 2.9.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Auxiliary functions from Lua API
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lapi_h
 8 | #define lapi_h
 9 | 
10 | 
11 | #include "llimits.h"
12 | #include "lstate.h"
13 | 
14 | #define api_incr_top(L)   {L->top++; api_check(L, L->top <= L->ci->top, \
15 | 				"stack overflow");}
16 | 
17 | #define adjustresults(L,nres) \
18 |     { if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }
19 | 
20 | #define api_checknelems(L,n)	api_check(L, (n) < (L->top - L->ci->func), \
21 | 				  "not enough elements in the stack")
22 | 
23 | 
24 | #endif
25 | 


--------------------------------------------------------------------------------
/convert.cpp:
--------------------------------------------------------------------------------
 1 | #include "lconvert.h"
 2 | #include <stdio.h>
 3 | 
 4 | int main(int argc, char **argv)
 5 | {
 6 | 	if (argc < 2)
 7 | 		return -1;
 8 | 
 9 | 	LConvert convert;
10 | 
11 | 	FILE* fin = fopen(argv[1],"r");
12 | 	if (!fin)
13 | 		return -2;
14 | 
15 | 	fseek(fin, 0, SEEK_END);
16 | 	long size = ftell(fin);
17 | 	char *buf = (char*)malloc(size+1);
18 | 	fseek(fin, 0, SEEK_SET);
19 | 	size_t read = fread(buf, 1, size, fin);
20 | 	if (read)
21 | 	{
22 | 		buf[read] = 0;
23 | 		std::string out;
24 | 		convert.Convert(buf, out);
25 | 
26 | 		std::string outName = argv[1];
27 | 		outName.append(".txt");
28 | 		FILE* fout = fopen(outName.c_str(), "w");
29 | 		if (fout)
30 | 		{
31 | 			fwrite(out.c_str(), out.length(), 1, fout);
32 | 			fclose(fout);
33 | 		}
34 | 	}
35 | 	fclose(fin);
36 | 	return 0;
37 | }
38 | 
39 | 
40 | 


--------------------------------------------------------------------------------
/lua52/lundump.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lundump.h,v 1.39.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** load precompiled Lua chunks
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lundump_h
 8 | #define lundump_h
 9 | 
10 | #include "lobject.h"
11 | #include "lzio.h"
12 | 
13 | /* load one chunk; from lundump.c */
14 | LUAI_FUNC Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
15 | 
16 | /* make header; from lundump.c */
17 | LUAI_FUNC void luaU_header (lu_byte* h);
18 | 
19 | /* dump one chunk; from ldump.c */
20 | LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);
21 | 
22 | /* data to catch conversion errors */
23 | #define LUAC_TAIL		"\x19\x93\r\n\x1a\n"
24 | 
25 | /* size in bytes of header of binary files */
26 | #define LUAC_HEADERSIZE		(sizeof(LUA_SIGNATURE)-sizeof(char)+2+6+sizeof(LUAC_TAIL)-sizeof(char))
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/lua51/linit.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: linit.c,v 1.14.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Initialization of libraries for lua.c
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #define linit_c
 9 | #define LUA_LIB
10 | 
11 | #include "lua.h"
12 | 
13 | #include "lualib.h"
14 | #include "lauxlib.h"
15 | 
16 | 
17 | static const luaL_Reg lualibs[] = {
18 |   {"", luaopen_base},
19 |   {LUA_LOADLIBNAME, luaopen_package},
20 |   {LUA_TABLIBNAME, luaopen_table},
21 |   {LUA_IOLIBNAME, luaopen_io},
22 |   {LUA_OSLIBNAME, luaopen_os},
23 |   {LUA_STRLIBNAME, luaopen_string},
24 |   {LUA_MATHLIBNAME, luaopen_math},
25 |   {LUA_DBLIBNAME, luaopen_debug},
26 |   {NULL, NULL}
27 | };
28 | 
29 | 
30 | LUALIB_API void luaL_openlibs (lua_State *L) {
31 |   const luaL_Reg *lib = lualibs;
32 |   for (; lib->func; lib++) {
33 |     lua_pushcfunction(L, lib->func);
34 |     lua_pushstring(L, lib->name);
35 |     lua_call(L, 1, 0);
36 |   }
37 | }
38 | 
39 | 


--------------------------------------------------------------------------------
/lua53/lundump.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lundump.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** load precompiled Lua chunks
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lundump_h
 8 | #define lundump_h
 9 | 
10 | #include "llimits.h"
11 | #include "lobject.h"
12 | #include "lzio.h"
13 | 
14 | 
15 | /* data to catch conversion errors */
16 | #define LUAC_DATA	"\x19\x93\r\n\x1a\n"
17 | 
18 | #define LUAC_INT	0x5678
19 | #define LUAC_NUM	cast_num(370.5)
20 | 
21 | #define MYINT(s)	(s[0]-'0')
22 | #define LUAC_VERSION	(MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR))
23 | #define LUAC_FORMAT	0	/* this is the official format */
24 | 
25 | /* load one chunk; from lundump.c */
26 | LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, const char* name);
27 | 
28 | /* dump one chunk; from ldump.c */
29 | LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w,
30 |                          void* data, int strip);
31 | 
32 | #endif
33 | 


--------------------------------------------------------------------------------
/lua51/lstring.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lstring.h,v 1.43.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** String table (keep all strings handled by Lua)
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lstring_h
 8 | #define lstring_h
 9 | 
10 | 
11 | #include "lgc.h"
12 | #include "lobject.h"
13 | #include "lstate.h"
14 | 
15 | 
16 | #define sizestring(s)	(sizeof(union TString)+((s)->len+1)*sizeof(char))
17 | 
18 | #define sizeudata(u)	(sizeof(union Udata)+(u)->len)
19 | 
20 | #define luaS_new(L, s)	(luaS_newlstr(L, s, strlen(s)))
21 | #define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
22 |                                  (sizeof(s)/sizeof(char))-1))
23 | 
24 | #define luaS_fix(s)	l_setbit((s)->tsv.marked, FIXEDBIT)
25 | 
26 | LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
27 | LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);
28 | LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
29 | 
30 | 
31 | #endif
32 | 


--------------------------------------------------------------------------------
/lua51/lundump.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lundump.h,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** load precompiled Lua chunks
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lundump_h
 8 | #define lundump_h
 9 | 
10 | #include "lobject.h"
11 | #include "lzio.h"
12 | 
13 | /* load one chunk; from lundump.c */
14 | LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
15 | 
16 | /* make header; from lundump.c */
17 | LUAI_FUNC void luaU_header (char* h);
18 | 
19 | /* dump one chunk; from ldump.c */
20 | LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);
21 | 
22 | #ifdef luac_c
23 | /* print one chunk; from print.c */
24 | LUAI_FUNC void luaU_print (const Proto* f, int full);
25 | #endif
26 | 
27 | /* for header of binary files -- this is Lua 5.1 */
28 | #define LUAC_VERSION		0x51
29 | 
30 | /* for header of binary files -- this is the official format */
31 | #define LUAC_FORMAT		0
32 | 
33 | /* size of header of binary files */
34 | #define LUAC_HEADERSIZE		12
35 | 
36 | #endif
37 | 


--------------------------------------------------------------------------------
/lua53/lprefix.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lprefix.h,v 1.2.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Definitions for Lua code that must come before any other header file
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lprefix_h
 8 | #define lprefix_h
 9 | 
10 | 
11 | /*
12 | ** Allows POSIX/XSI stuff
13 | */
14 | #if !defined(LUA_USE_C89)	/* { */
15 | 
16 | #if !defined(_XOPEN_SOURCE)
17 | #define _XOPEN_SOURCE           600
18 | #elif _XOPEN_SOURCE == 0
19 | #undef _XOPEN_SOURCE  /* use -D_XOPEN_SOURCE=0 to undefine it */
20 | #endif
21 | 
22 | /*
23 | ** Allows manipulation of large files in gcc and some other compilers
24 | */
25 | #if !defined(LUA_32BITS) && !defined(_FILE_OFFSET_BITS)
26 | #define _LARGEFILE_SOURCE       1
27 | #define _FILE_OFFSET_BITS       64
28 | #endif
29 | 
30 | #endif				/* } */
31 | 
32 | 
33 | /*
34 | ** Windows stuff
35 | */
36 | #if defined(_WIN32) 	/* { */
37 | 
38 | #if !defined(_CRT_SECURE_NO_WARNINGS)
39 | #define _CRT_SECURE_NO_WARNINGS  /* avoid warnings about ISO C functions */
40 | #endif
41 | 
42 | #endif			/* } */
43 | 
44 | #endif
45 | 
46 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 方振涛
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/lua52/lfunc.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lfunc.h,v 2.8.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Auxiliary functions to manipulate prototypes and closures
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lfunc_h
 8 | #define lfunc_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | 
13 | 
14 | #define sizeCclosure(n)	(cast(int, sizeof(CClosure)) + \
15 |                          cast(int, sizeof(TValue)*((n)-1)))
16 | 
17 | #define sizeLclosure(n)	(cast(int, sizeof(LClosure)) + \
18 |                          cast(int, sizeof(TValue *)*((n)-1)))
19 | 
20 | 
21 | LUAI_FUNC Proto *luaF_newproto (lua_State *L);
22 | LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems);
23 | LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems);
24 | LUAI_FUNC UpVal *luaF_newupval (lua_State *L);
25 | LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
26 | LUAI_FUNC void luaF_close (lua_State *L, StkId level);
27 | LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
28 | LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);
29 | LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
30 |                                          int pc);
31 | 
32 | 
33 | #endif
34 | 


--------------------------------------------------------------------------------
/lua51/ldebug.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ldebug.h,v 2.3.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Auxiliary functions from Debug Interface module
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ldebug_h
 8 | #define ldebug_h
 9 | 
10 | 
11 | #include "lstate.h"
12 | 
13 | 
14 | #define pcRel(pc, p)	(cast(int, (pc) - (p)->code) - 1)
15 | 
16 | #define getline(f,pc)	(((f)->lineinfo) ? (f)->lineinfo[pc] : 0)
17 | 
18 | #define resethookcount(L)	(L->hookcount = L->basehookcount)
19 | 
20 | 
21 | LUAI_FUNC void luaG_typeerror (lua_State *L, const TValue *o,
22 |                                              const char *opname);
23 | LUAI_FUNC void luaG_concaterror (lua_State *L, StkId p1, StkId p2);
24 | LUAI_FUNC void luaG_aritherror (lua_State *L, const TValue *p1,
25 |                                               const TValue *p2);
26 | LUAI_FUNC int luaG_ordererror (lua_State *L, const TValue *p1,
27 |                                              const TValue *p2);
28 | LUAI_FUNC void luaG_runerror (lua_State *L, const char *fmt, ...);
29 | LUAI_FUNC void luaG_errormsg (lua_State *L);
30 | LUAI_FUNC int luaG_checkcode (const Proto *pt);
31 | LUAI_FUNC int luaG_checkopenop (Instruction i);
32 | 
33 | #endif
34 | 


--------------------------------------------------------------------------------
/lua52/ldebug.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ldebug.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Auxiliary functions from Debug Interface module
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ldebug_h
 8 | #define ldebug_h
 9 | 
10 | 
11 | #include "lstate.h"
12 | 
13 | 
14 | #define pcRel(pc, p)	(cast(int, (pc) - (p)->code) - 1)
15 | 
16 | #define getfuncline(f,pc)	(((f)->lineinfo) ? (f)->lineinfo[pc] : 0)
17 | 
18 | #define resethookcount(L)	(L->hookcount = L->basehookcount)
19 | 
20 | /* Active Lua function (given call info) */
21 | #define ci_func(ci)		(clLvalue((ci)->func))
22 | 
23 | 
24 | LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,
25 |                                                 const char *opname);
26 | LUAI_FUNC l_noret luaG_concaterror (lua_State *L, StkId p1, StkId p2);
27 | LUAI_FUNC l_noret luaG_aritherror (lua_State *L, const TValue *p1,
28 |                                                  const TValue *p2);
29 | LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1,
30 |                                                  const TValue *p2);
31 | LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
32 | LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
33 | 
34 | #endif
35 | 


--------------------------------------------------------------------------------
/lua51/ltm.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltm.h,v 2.6.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Tag methods
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ltm_h
 8 | #define ltm_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | 
13 | 
14 | /*
15 | * WARNING: if you change the order of this enumeration,
16 | * grep "ORDER TM"
17 | */
18 | typedef enum {
19 |   TM_INDEX,
20 |   TM_NEWINDEX,
21 |   TM_GC,
22 |   TM_MODE,
23 |   TM_EQ,  /* last tag method with `fast' access */
24 |   TM_ADD,
25 |   TM_SUB,
26 |   TM_MUL,
27 |   TM_DIV,
28 |   TM_MOD,
29 |   TM_POW,
30 |   TM_UNM,
31 |   TM_LEN,
32 |   TM_LT,
33 |   TM_LE,
34 |   TM_CONCAT,
35 |   TM_CALL,
36 |   TM_N		/* number of elements in the enum */
37 | } TMS;
38 | 
39 | 
40 | 
41 | #define gfasttm(g,et,e) ((et) == NULL ? NULL : \
42 |   ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
43 | 
44 | #define fasttm(l,et,e)	gfasttm(G(l), et, e)
45 | 
46 | LUAI_DATA const char *const luaT_typenames[];
47 | 
48 | 
49 | LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);
50 | LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
51 |                                                        TMS event);
52 | LUAI_FUNC void luaT_init (lua_State *L);
53 | 
54 | #endif
55 | 


--------------------------------------------------------------------------------
/lua51/lualib.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lualib.h,v 1.36.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Lua standard libraries
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #ifndef lualib_h
 9 | #define lualib_h
10 | 
11 | #include "lua.h"
12 | 
13 | 
14 | /* Key to file-handle type */
15 | #define LUA_FILEHANDLE		"FILE*"
16 | 
17 | 
18 | #define LUA_COLIBNAME	"coroutine"
19 | LUALIB_API int (luaopen_base) (lua_State *L);
20 | 
21 | #define LUA_TABLIBNAME	"table"
22 | LUALIB_API int (luaopen_table) (lua_State *L);
23 | 
24 | #define LUA_IOLIBNAME	"io"
25 | LUALIB_API int (luaopen_io) (lua_State *L);
26 | 
27 | #define LUA_OSLIBNAME	"os"
28 | LUALIB_API int (luaopen_os) (lua_State *L);
29 | 
30 | #define LUA_STRLIBNAME	"string"
31 | LUALIB_API int (luaopen_string) (lua_State *L);
32 | 
33 | #define LUA_MATHLIBNAME	"math"
34 | LUALIB_API int (luaopen_math) (lua_State *L);
35 | 
36 | #define LUA_DBLIBNAME	"debug"
37 | LUALIB_API int (luaopen_debug) (lua_State *L);
38 | 
39 | #define LUA_LOADLIBNAME	"package"
40 | LUALIB_API int (luaopen_package) (lua_State *L);
41 | 
42 | 
43 | /* open all previous libraries */
44 | LUALIB_API void (luaL_openlibs) (lua_State *L); 
45 | 
46 | 
47 | 
48 | #ifndef lua_assert
49 | #define lua_assert(x)	((void)0)
50 | #endif
51 | 
52 | 
53 | #endif
54 | 


--------------------------------------------------------------------------------
/lua51/lfunc.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lfunc.h,v 2.4.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Auxiliary functions to manipulate prototypes and closures
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lfunc_h
 8 | #define lfunc_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | 
13 | 
14 | #define sizeCclosure(n)	(cast(int, sizeof(CClosure)) + \
15 |                          cast(int, sizeof(TValue)*((n)-1)))
16 | 
17 | #define sizeLclosure(n)	(cast(int, sizeof(LClosure)) + \
18 |                          cast(int, sizeof(TValue *)*((n)-1)))
19 | 
20 | 
21 | LUAI_FUNC Proto *luaF_newproto (lua_State *L);
22 | LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e);
23 | LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e);
24 | LUAI_FUNC UpVal *luaF_newupval (lua_State *L);
25 | LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
26 | LUAI_FUNC void luaF_close (lua_State *L, StkId level);
27 | LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
28 | LUAI_FUNC void luaF_freeclosure (lua_State *L, Closure *c);
29 | LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);
30 | LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
31 |                                          int pc);
32 | 
33 | 
34 | #endif
35 | 


--------------------------------------------------------------------------------
/lua51/lvm.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lvm.h,v 2.5.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Lua virtual machine
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lvm_h
 8 | #define lvm_h
 9 | 
10 | 
11 | #include "ldo.h"
12 | #include "lobject.h"
13 | #include "ltm.h"
14 | 
15 | 
16 | #define tostring(L,o) ((ttype(o) == LUA_TSTRING) || (luaV_tostring(L, o)))
17 | 
18 | #define tonumber(o,n)	(ttype(o) == LUA_TNUMBER || \
19 |                          (((o) = luaV_tonumber(o,n)) != NULL))
20 | 
21 | #define equalobj(L,o1,o2) \
22 | 	(ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2))
23 | 
24 | 
25 | LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
26 | LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
27 | LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
28 | LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
29 | LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key,
30 |                                             StkId val);
31 | LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key,
32 |                                             StkId val);
33 | LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);
34 | LUAI_FUNC void luaV_concat (lua_State *L, int total, int last);
35 | 
36 | #endif
37 | 


--------------------------------------------------------------------------------
/lua52/lualib.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lualib.h,v 1.43.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Lua standard libraries
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #ifndef lualib_h
 9 | #define lualib_h
10 | 
11 | #include "lua.h"
12 | 
13 | 
14 | 
15 | LUAMOD_API int (luaopen_base) (lua_State *L);
16 | 
17 | #define LUA_COLIBNAME	"coroutine"
18 | LUAMOD_API int (luaopen_coroutine) (lua_State *L);
19 | 
20 | #define LUA_TABLIBNAME	"table"
21 | LUAMOD_API int (luaopen_table) (lua_State *L);
22 | 
23 | #define LUA_IOLIBNAME	"io"
24 | LUAMOD_API int (luaopen_io) (lua_State *L);
25 | 
26 | #define LUA_OSLIBNAME	"os"
27 | LUAMOD_API int (luaopen_os) (lua_State *L);
28 | 
29 | #define LUA_STRLIBNAME	"string"
30 | LUAMOD_API int (luaopen_string) (lua_State *L);
31 | 
32 | #define LUA_BITLIBNAME	"bit32"
33 | LUAMOD_API int (luaopen_bit32) (lua_State *L);
34 | 
35 | #define LUA_MATHLIBNAME	"math"
36 | LUAMOD_API int (luaopen_math) (lua_State *L);
37 | 
38 | #define LUA_DBLIBNAME	"debug"
39 | LUAMOD_API int (luaopen_debug) (lua_State *L);
40 | 
41 | #define LUA_LOADLIBNAME	"package"
42 | LUAMOD_API int (luaopen_package) (lua_State *L);
43 | 
44 | 
45 | /* open all previous libraries */
46 | LUALIB_API void (luaL_openlibs) (lua_State *L);
47 | 
48 | 
49 | 
50 | #if !defined(lua_assert)
51 | #define lua_assert(x)	((void)0)
52 | #endif
53 | 
54 | 
55 | #endif
56 | 


--------------------------------------------------------------------------------
/lua51/ltable.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltable.h,v 2.10.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Lua tables (hash)
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ltable_h
 8 | #define ltable_h
 9 | 
10 | #include "lobject.h"
11 | 
12 | 
13 | #define gnode(t,i)	(&(t)->node[i])
14 | #define gkey(n)		(&(n)->i_key.nk)
15 | #define gval(n)		(&(n)->i_val)
16 | #define gnext(n)	((n)->i_key.nk.next)
17 | 
18 | #define key2tval(n)	(&(n)->i_key.tvk)
19 | 
20 | 
21 | LUAI_FUNC const TValue *luaH_getnum (Table *t, int key);
22 | LUAI_FUNC TValue *luaH_setnum (lua_State *L, Table *t, int key);
23 | LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
24 | LUAI_FUNC TValue *luaH_setstr (lua_State *L, Table *t, TString *key);
25 | LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
26 | LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key);
27 | LUAI_FUNC Table *luaH_new (lua_State *L, int narray, int lnhash);
28 | LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize);
29 | LUAI_FUNC void luaH_free (lua_State *L, Table *t);
30 | LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
31 | LUAI_FUNC int luaH_getn (Table *t);
32 | 
33 | 
34 | #if defined(LUA_DEBUG)
35 | LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
36 | LUAI_FUNC int luaH_isdummy (Node *n);
37 | #endif
38 | 
39 | 
40 | #endif
41 | 


--------------------------------------------------------------------------------
/lua52/ltm.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltm.h,v 2.11.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Tag methods
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ltm_h
 8 | #define ltm_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | 
13 | 
14 | /*
15 | * WARNING: if you change the order of this enumeration,
16 | * grep "ORDER TM"
17 | */
18 | typedef enum {
19 |   TM_INDEX,
20 |   TM_NEWINDEX,
21 |   TM_GC,
22 |   TM_MODE,
23 |   TM_LEN,
24 |   TM_EQ,  /* last tag method with `fast' access */
25 |   TM_ADD,
26 |   TM_SUB,
27 |   TM_MUL,
28 |   TM_DIV,
29 |   TM_MOD,
30 |   TM_POW,
31 |   TM_UNM,
32 |   TM_LT,
33 |   TM_LE,
34 |   TM_CONCAT,
35 |   TM_CALL,
36 |   TM_N		/* number of elements in the enum */
37 | } TMS;
38 | 
39 | 
40 | 
41 | #define gfasttm(g,et,e) ((et) == NULL ? NULL : \
42 |   ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
43 | 
44 | #define fasttm(l,et,e)	gfasttm(G(l), et, e)
45 | 
46 | #define ttypename(x)	luaT_typenames_[(x) + 1]
47 | #define objtypename(x)	ttypename(ttypenv(x))
48 | 
49 | LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS];
50 | 
51 | 
52 | LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);
53 | LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
54 |                                                        TMS event);
55 | LUAI_FUNC void luaT_init (lua_State *L);
56 | 
57 | #endif
58 | 


--------------------------------------------------------------------------------
/lua52/lstring.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lstring.h,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** String table (keep all strings handled by Lua)
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lstring_h
 8 | #define lstring_h
 9 | 
10 | #include "lgc.h"
11 | #include "lobject.h"
12 | #include "lstate.h"
13 | 
14 | 
15 | #define sizestring(s)	(sizeof(union TString)+((s)->len+1)*sizeof(char))
16 | 
17 | #define sizeudata(u)	(sizeof(union Udata)+(u)->len)
18 | 
19 | #define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
20 |                                  (sizeof(s)/sizeof(char))-1))
21 | 
22 | #define luaS_fix(s)	l_setbit((s)->tsv.marked, FIXEDBIT)
23 | 
24 | 
25 | /*
26 | ** test whether a string is a reserved word
27 | */
28 | #define isreserved(s)	((s)->tsv.tt == LUA_TSHRSTR && (s)->tsv.extra > 0)
29 | 
30 | 
31 | /*
32 | ** equality for short strings, which are always internalized
33 | */
34 | #define eqshrstr(a,b)	check_exp((a)->tsv.tt == LUA_TSHRSTR, (a) == (b))
35 | 
36 | 
37 | LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);
38 | LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b);
39 | LUAI_FUNC int luaS_eqstr (TString *a, TString *b);
40 | LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
41 | LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);
42 | LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
43 | LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
44 | 
45 | 
46 | #endif
47 | 


--------------------------------------------------------------------------------
/lua53/lualib.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lualib.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Lua standard libraries
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #ifndef lualib_h
 9 | #define lualib_h
10 | 
11 | #include "lua.h"
12 | 
13 | 
14 | /* version suffix for environment variable names */
15 | #define LUA_VERSUFFIX          "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
16 | 
17 | 
18 | LUAMOD_API int (luaopen_base) (lua_State *L);
19 | 
20 | #define LUA_COLIBNAME	"coroutine"
21 | LUAMOD_API int (luaopen_coroutine) (lua_State *L);
22 | 
23 | #define LUA_TABLIBNAME	"table"
24 | LUAMOD_API int (luaopen_table) (lua_State *L);
25 | 
26 | #define LUA_IOLIBNAME	"io"
27 | LUAMOD_API int (luaopen_io) (lua_State *L);
28 | 
29 | #define LUA_OSLIBNAME	"os"
30 | LUAMOD_API int (luaopen_os) (lua_State *L);
31 | 
32 | #define LUA_STRLIBNAME	"string"
33 | LUAMOD_API int (luaopen_string) (lua_State *L);
34 | 
35 | #define LUA_UTF8LIBNAME	"utf8"
36 | LUAMOD_API int (luaopen_utf8) (lua_State *L);
37 | 
38 | #define LUA_BITLIBNAME	"bit32"
39 | LUAMOD_API int (luaopen_bit32) (lua_State *L);
40 | 
41 | #define LUA_MATHLIBNAME	"math"
42 | LUAMOD_API int (luaopen_math) (lua_State *L);
43 | 
44 | #define LUA_DBLIBNAME	"debug"
45 | LUAMOD_API int (luaopen_debug) (lua_State *L);
46 | 
47 | #define LUA_LOADLIBNAME	"package"
48 | LUAMOD_API int (luaopen_package) (lua_State *L);
49 | 
50 | 
51 | /* open all previous libraries */
52 | LUALIB_API void (luaL_openlibs) (lua_State *L);
53 | 
54 | 
55 | 
56 | #if !defined(lua_assert)
57 | #define lua_assert(x)	((void)0)
58 | #endif
59 | 
60 | 
61 | #endif
62 | 


--------------------------------------------------------------------------------
/lua52/ltable.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltable.h,v 2.16.1.2 2013/08/30 15:49:41 roberto Exp $
 3 | ** Lua tables (hash)
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ltable_h
 8 | #define ltable_h
 9 | 
10 | #include "lobject.h"
11 | 
12 | 
13 | #define gnode(t,i)	(&(t)->node[i])
14 | #define gkey(n)		(&(n)->i_key.tvk)
15 | #define gval(n)		(&(n)->i_val)
16 | #define gnext(n)	((n)->i_key.nk.next)
17 | 
18 | #define invalidateTMcache(t)	((t)->flags = 0)
19 | 
20 | /* returns the key, given the value of a table entry */
21 | #define keyfromval(v) \
22 |   (gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val))))
23 | 
24 | 
25 | LUAI_FUNC const TValue *luaH_getint (Table *t, int key);
26 | LUAI_FUNC void luaH_setint (lua_State *L, Table *t, int key, TValue *value);
27 | LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
28 | LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
29 | LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key);
30 | LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key);
31 | LUAI_FUNC Table *luaH_new (lua_State *L);
32 | LUAI_FUNC void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize);
33 | LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize);
34 | LUAI_FUNC void luaH_free (lua_State *L, Table *t);
35 | LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
36 | LUAI_FUNC int luaH_getn (Table *t);
37 | 
38 | 
39 | #if defined(LUA_DEBUG)
40 | LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
41 | LUAI_FUNC int luaH_isdummy (Node *n);
42 | #endif
43 | 
44 | 
45 | #endif
46 | 


--------------------------------------------------------------------------------
/lua53/ldebug.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ldebug.h,v 2.14.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Auxiliary functions from Debug Interface module
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ldebug_h
 8 | #define ldebug_h
 9 | 
10 | 
11 | #include "lstate.h"
12 | 
13 | 
14 | #define pcRel(pc, p)	(cast(int, (pc) - (p)->code) - 1)
15 | 
16 | #define getfuncline(f,pc)	(((f)->lineinfo) ? (f)->lineinfo[pc] : -1)
17 | 
18 | #define resethookcount(L)	(L->hookcount = L->basehookcount)
19 | 
20 | 
21 | LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,
22 |                                                 const char *opname);
23 | LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1,
24 |                                                   const TValue *p2);
25 | LUAI_FUNC l_noret luaG_opinterror (lua_State *L, const TValue *p1,
26 |                                                  const TValue *p2,
27 |                                                  const char *msg);
28 | LUAI_FUNC l_noret luaG_tointerror (lua_State *L, const TValue *p1,
29 |                                                  const TValue *p2);
30 | LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1,
31 |                                                  const TValue *p2);
32 | LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
33 | LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg,
34 |                                                   TString *src, int line);
35 | LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
36 | LUAI_FUNC void luaG_traceexec (lua_State *L);
37 | 
38 | 
39 | #endif
40 | 


--------------------------------------------------------------------------------
/lua52/lvm.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lvm.h,v 2.18.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Lua virtual machine
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lvm_h
 8 | #define lvm_h
 9 | 
10 | 
11 | #include "ldo.h"
12 | #include "lobject.h"
13 | #include "ltm.h"
14 | 
15 | 
16 | #define tostring(L,o) (ttisstring(o) || (luaV_tostring(L, o)))
17 | 
18 | #define tonumber(o,n)	(ttisnumber(o) || (((o) = luaV_tonumber(o,n)) != NULL))
19 | 
20 | #define equalobj(L,o1,o2)  (ttisequal(o1, o2) && luaV_equalobj_(L, o1, o2))
21 | 
22 | #define luaV_rawequalobj(o1,o2)		equalobj(NULL,o1,o2)
23 | 
24 | 
25 | /* not to called directly */
26 | LUAI_FUNC int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2);
27 | 
28 | 
29 | LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
30 | LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r);
31 | LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
32 | LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
33 | LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key,
34 |                                             StkId val);
35 | LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key,
36 |                                             StkId val);
37 | LUAI_FUNC void luaV_finishOp (lua_State *L);
38 | LUAI_FUNC void luaV_execute (lua_State *L);
39 | LUAI_FUNC void luaV_concat (lua_State *L, int total);
40 | LUAI_FUNC void luaV_arith (lua_State *L, StkId ra, const TValue *rb,
41 |                            const TValue *rc, TMS op);
42 | LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb);
43 | 
44 | #endif
45 | 


--------------------------------------------------------------------------------
/lua53/lstring.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lstring.h,v 1.61.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** String table (keep all strings handled by Lua)
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lstring_h
 8 | #define lstring_h
 9 | 
10 | #include "lgc.h"
11 | #include "lobject.h"
12 | #include "lstate.h"
13 | 
14 | 
15 | #define sizelstring(l)  (sizeof(union UTString) + ((l) + 1) * sizeof(char))
16 | 
17 | #define sizeludata(l)	(sizeof(union UUdata) + (l))
18 | #define sizeudata(u)	sizeludata((u)->len)
19 | 
20 | #define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
21 |                                  (sizeof(s)/sizeof(char))-1))
22 | 
23 | 
24 | /*
25 | ** test whether a string is a reserved word
26 | */
27 | #define isreserved(s)	((s)->tt == LUA_TSHRSTR && (s)->extra > 0)
28 | 
29 | 
30 | /*
31 | ** equality for short strings, which are always internalized
32 | */
33 | #define eqshrstr(a,b)	check_exp((a)->tt == LUA_TSHRSTR, (a) == (b))
34 | 
35 | 
36 | LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);
37 | LUAI_FUNC unsigned int luaS_hashlongstr (TString *ts);
38 | LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b);
39 | LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
40 | LUAI_FUNC void luaS_clearcache (global_State *g);
41 | LUAI_FUNC void luaS_init (lua_State *L);
42 | LUAI_FUNC void luaS_remove (lua_State *L, TString *ts);
43 | LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s);
44 | LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
45 | LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
46 | LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l);
47 | 
48 | 
49 | #endif
50 | 


--------------------------------------------------------------------------------
/lua53/lzio.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lzio.c,v 1.37.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Buffered streams
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #define lzio_c
 8 | #define LUA_CORE
 9 | 
10 | #include "lprefix.h"
11 | 
12 | 
13 | #include <string.h>
14 | 
15 | #include "lua.h"
16 | 
17 | #include "llimits.h"
18 | #include "lmem.h"
19 | #include "lstate.h"
20 | #include "lzio.h"
21 | 
22 | 
23 | int luaZ_fill (ZIO *z) {
24 |   size_t size;
25 |   lua_State *L = z->L;
26 |   const char *buff;
27 |   lua_unlock(L);
28 |   buff = z->reader(L, z->data, &size);
29 |   lua_lock(L);
30 |   if (buff == NULL || size == 0)
31 |     return EOZ;
32 |   z->n = size - 1;  /* discount char being returned */
33 |   z->p = buff;
34 |   return cast_uchar(*(z->p++));
35 | }
36 | 
37 | 
38 | void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
39 |   z->L = L;
40 |   z->reader = reader;
41 |   z->data = data;
42 |   z->n = 0;
43 |   z->p = NULL;
44 | }
45 | 
46 | 
47 | /* --------------------------------------------------------------- read --- */
48 | size_t luaZ_read (ZIO *z, void *b, size_t n) {
49 |   while (n) {
50 |     size_t m;
51 |     if (z->n == 0) {  /* no bytes in buffer? */
52 |       if (luaZ_fill(z) == EOZ)  /* try to read more */
53 |         return n;  /* no more input; return number of missing bytes */
54 |       else {
55 |         z->n++;  /* luaZ_fill consumed first byte; put it back */
56 |         z->p--;
57 |       }
58 |     }
59 |     m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
60 |     memcpy(b, z->p, m);
61 |     z->n -= m;
62 |     z->p += m;
63 |     b = (char *)b + m;
64 |     n -= m;
65 |   }
66 |   return 0;
67 | }
68 | 
69 | 


--------------------------------------------------------------------------------
/lua51/lmem.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lmem.h,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Interface to Memory Manager
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lmem_h
 8 | #define lmem_h
 9 | 
10 | 
11 | #include <stddef.h>
12 | 
13 | #include "llimits.h"
14 | #include "lua.h"
15 | 
16 | #define MEMERRMSG	"not enough memory"
17 | 
18 | 
19 | #define luaM_reallocv(L,b,on,n,e) \
20 | 	((cast(size_t, (n)+1) <= MAX_SIZET/(e)) ?  /* +1 to avoid warnings */ \
21 | 		luaM_realloc_(L, (b), (on)*(e), (n)*(e)) : \
22 | 		luaM_toobig(L))
23 | 
24 | #define luaM_freemem(L, b, s)	luaM_realloc_(L, (b), (s), 0)
25 | #define luaM_free(L, b)		luaM_realloc_(L, (b), sizeof(*(b)), 0)
26 | #define luaM_freearray(L, b, n, t)   luaM_reallocv(L, (b), n, 0, sizeof(t))
27 | 
28 | #define luaM_malloc(L,t)	luaM_realloc_(L, NULL, 0, (t))
29 | #define luaM_new(L,t)		cast(t *, luaM_malloc(L, sizeof(t)))
30 | #define luaM_newvector(L,n,t) \
31 | 		cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
32 | 
33 | #define luaM_growvector(L,v,nelems,size,t,limit,e) \
34 |           if ((nelems)+1 > (size)) \
35 |             ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
36 | 
37 | #define luaM_reallocvector(L, v,oldn,n,t) \
38 |    ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
39 | 
40 | 
41 | LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
42 |                                                           size_t size);
43 | LUAI_FUNC void *luaM_toobig (lua_State *L);
44 | LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
45 |                                size_t size_elem, int limit,
46 |                                const char *errormsg);
47 | 
48 | #endif
49 | 
50 | 


--------------------------------------------------------------------------------
/lua52/ldo.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ldo.h,v 2.20.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Stack and Call structure of Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ldo_h
 8 | #define ldo_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | #include "lstate.h"
13 | #include "lzio.h"
14 | 
15 | 
16 | #define luaD_checkstack(L,n)	if (L->stack_last - L->top <= (n)) \
17 | 				    luaD_growstack(L, n); else condmovestack(L);
18 | 
19 | 
20 | #define incr_top(L) {L->top++; luaD_checkstack(L,0);}
21 | 
22 | #define savestack(L,p)		((char *)(p) - (char *)L->stack)
23 | #define restorestack(L,n)	((TValue *)((char *)L->stack + (n)))
24 | 
25 | 
26 | /* type of protected functions, to be ran by `runprotected' */
27 | typedef void (*Pfunc) (lua_State *L, void *ud);
28 | 
29 | LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
30 |                                                   const char *mode);
31 | LUAI_FUNC void luaD_hook (lua_State *L, int event, int line);
32 | LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
33 | LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults,
34 |                                         int allowyield);
35 | LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
36 |                                         ptrdiff_t oldtop, ptrdiff_t ef);
37 | LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);
38 | LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
39 | LUAI_FUNC void luaD_growstack (lua_State *L, int n);
40 | LUAI_FUNC void luaD_shrinkstack (lua_State *L);
41 | 
42 | LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
43 | LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
44 | 
45 | #endif
46 | 
47 | 


--------------------------------------------------------------------------------
/lua52/lzio.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lzio.h,v 1.26.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Buffered streams
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #ifndef lzio_h
 9 | #define lzio_h
10 | 
11 | #include "lua.h"
12 | 
13 | #include "lmem.h"
14 | 
15 | 
16 | #define EOZ	(-1)			/* end of stream */
17 | 
18 | typedef struct Zio ZIO;
19 | 
20 | #define zgetc(z)  (((z)->n--)>0 ?  cast_uchar(*(z)->p++) : luaZ_fill(z))
21 | 
22 | 
23 | typedef struct Mbuffer {
24 |   char *buffer;
25 |   size_t n;
26 |   size_t buffsize;
27 | } Mbuffer;
28 | 
29 | #define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
30 | 
31 | #define luaZ_buffer(buff)	((buff)->buffer)
32 | #define luaZ_sizebuffer(buff)	((buff)->buffsize)
33 | #define luaZ_bufflen(buff)	((buff)->n)
34 | 
35 | #define luaZ_resetbuffer(buff) ((buff)->n = 0)
36 | 
37 | 
38 | #define luaZ_resizebuffer(L, buff, size) \
39 | 	(luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \
40 | 	(buff)->buffsize = size)
41 | 
42 | #define luaZ_freebuffer(L, buff)	luaZ_resizebuffer(L, buff, 0)
43 | 
44 | 
45 | LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n);
46 | LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
47 |                                         void *data);
48 | LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n);	/* read next n bytes */
49 | 
50 | 
51 | 
52 | /* --------- Private Part ------------------ */
53 | 
54 | struct Zio {
55 |   size_t n;			/* bytes still unread */
56 |   const char *p;		/* current position in buffer */
57 |   lua_Reader reader;		/* reader function */
58 |   void* data;			/* additional data */
59 |   lua_State *L;			/* Lua state (for reader) */
60 | };
61 | 
62 | 
63 | LUAI_FUNC int luaZ_fill (ZIO *z);
64 | 
65 | #endif
66 | 


--------------------------------------------------------------------------------
/lua53/lzio.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lzio.h,v 1.31.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Buffered streams
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #ifndef lzio_h
 9 | #define lzio_h
10 | 
11 | #include "lua.h"
12 | 
13 | #include "lmem.h"
14 | 
15 | 
16 | #define EOZ	(-1)			/* end of stream */
17 | 
18 | typedef struct Zio ZIO;
19 | 
20 | #define zgetc(z)  (((z)->n--)>0 ?  cast_uchar(*(z)->p++) : luaZ_fill(z))
21 | 
22 | 
23 | typedef struct Mbuffer {
24 |   char *buffer;
25 |   size_t n;
26 |   size_t buffsize;
27 | } Mbuffer;
28 | 
29 | #define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
30 | 
31 | #define luaZ_buffer(buff)	((buff)->buffer)
32 | #define luaZ_sizebuffer(buff)	((buff)->buffsize)
33 | #define luaZ_bufflen(buff)	((buff)->n)
34 | 
35 | #define luaZ_buffremove(buff,i)	((buff)->n -= (i))
36 | #define luaZ_resetbuffer(buff) ((buff)->n = 0)
37 | 
38 | 
39 | #define luaZ_resizebuffer(L, buff, size) \
40 | 	((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \
41 | 				(buff)->buffsize, size), \
42 | 	(buff)->buffsize = size)
43 | 
44 | #define luaZ_freebuffer(L, buff)	luaZ_resizebuffer(L, buff, 0)
45 | 
46 | 
47 | LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
48 |                                         void *data);
49 | LUAI_FUNC size_t luaZ_read (ZIO* z, void *b, size_t n);	/* read next n bytes */
50 | 
51 | 
52 | 
53 | /* --------- Private Part ------------------ */
54 | 
55 | struct Zio {
56 |   size_t n;			/* bytes still unread */
57 |   const char *p;		/* current position in buffer */
58 |   lua_Reader reader;		/* reader function */
59 |   void *data;			/* additional data */
60 |   lua_State *L;			/* Lua state (for reader) */
61 | };
62 | 
63 | 
64 | LUAI_FUNC int luaZ_fill (ZIO *z);
65 | 
66 | #endif
67 | 


--------------------------------------------------------------------------------
/lua51/lzio.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lzio.h,v 1.21.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Buffered streams
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #ifndef lzio_h
 9 | #define lzio_h
10 | 
11 | #include "lua.h"
12 | 
13 | #include "lmem.h"
14 | 
15 | 
16 | #define EOZ	(-1)			/* end of stream */
17 | 
18 | typedef struct Zio ZIO;
19 | 
20 | #define char2int(c)	cast(int, cast(unsigned char, (c)))
21 | 
22 | #define zgetc(z)  (((z)->n--)>0 ?  char2int(*(z)->p++) : luaZ_fill(z))
23 | 
24 | typedef struct Mbuffer {
25 |   char *buffer;
26 |   size_t n;
27 |   size_t buffsize;
28 | } Mbuffer;
29 | 
30 | #define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
31 | 
32 | #define luaZ_buffer(buff)	((buff)->buffer)
33 | #define luaZ_sizebuffer(buff)	((buff)->buffsize)
34 | #define luaZ_bufflen(buff)	((buff)->n)
35 | 
36 | #define luaZ_resetbuffer(buff) ((buff)->n = 0)
37 | 
38 | 
39 | #define luaZ_resizebuffer(L, buff, size) \
40 | 	(luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \
41 | 	(buff)->buffsize = size)
42 | 
43 | #define luaZ_freebuffer(L, buff)	luaZ_resizebuffer(L, buff, 0)
44 | 
45 | 
46 | LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n);
47 | LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
48 |                                         void *data);
49 | LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n);	/* read next n bytes */
50 | LUAI_FUNC int luaZ_lookahead (ZIO *z);
51 | 
52 | 
53 | 
54 | /* --------- Private Part ------------------ */
55 | 
56 | struct Zio {
57 |   size_t n;			/* bytes still unread */
58 |   const char *p;		/* current position in buffer */
59 |   lua_Reader reader;
60 |   void* data;			/* additional data */
61 |   lua_State *L;			/* Lua state (for reader) */
62 | };
63 | 
64 | 
65 | LUAI_FUNC int luaZ_fill (ZIO *z);
66 | 
67 | #endif
68 | 


--------------------------------------------------------------------------------
/lua53/lfunc.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lfunc.h,v 2.15.1.1 2017/04/19 17:39:34 roberto Exp $
 3 | ** Auxiliary functions to manipulate prototypes and closures
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lfunc_h
 8 | #define lfunc_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | 
13 | 
14 | #define sizeCclosure(n)	(cast(int, sizeof(CClosure)) + \
15 |                          cast(int, sizeof(TValue)*((n)-1)))
16 | 
17 | #define sizeLclosure(n)	(cast(int, sizeof(LClosure)) + \
18 |                          cast(int, sizeof(TValue *)*((n)-1)))
19 | 
20 | 
21 | /* test whether thread is in 'twups' list */
22 | #define isintwups(L)	(L->twups != L)
23 | 
24 | 
25 | /*
26 | ** maximum number of upvalues in a closure (both C and Lua). (Value
27 | ** must fit in a VM register.)
28 | */
29 | #define MAXUPVAL	255
30 | 
31 | 
32 | /*
33 | ** Upvalues for Lua closures
34 | */
35 | struct UpVal {
36 |   TValue *v;  /* points to stack or to its own value */
37 |   lu_mem refcount;  /* reference counter */
38 |   union {
39 |     struct {  /* (when open) */
40 |       UpVal *next;  /* linked list */
41 |       int touched;  /* mark to avoid cycles with dead threads */
42 |     } open;
43 |     TValue value;  /* the value (when closed) */
44 |   } u;
45 | };
46 | 
47 | #define upisopen(up)	((up)->v != &(up)->u.value)
48 | 
49 | 
50 | LUAI_FUNC Proto *luaF_newproto (lua_State *L);
51 | LUAI_FUNC CClosure *luaF_newCclosure (lua_State *L, int nelems);
52 | LUAI_FUNC LClosure *luaF_newLclosure (lua_State *L, int nelems);
53 | LUAI_FUNC void luaF_initupvals (lua_State *L, LClosure *cl);
54 | LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
55 | LUAI_FUNC void luaF_close (lua_State *L, StkId level);
56 | LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
57 | LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
58 |                                          int pc);
59 | 
60 | 
61 | #endif
62 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | ## LuaChinese
 2 | 
 3 | 旨在提供中文lua运行环境，支持中文标识符，中文（或中英文混合）变量名，中文编码支持gb2312及utf8,如果脚本使用utf8编码编译时请在luaconf.h中定义UNICODE宏后进行编译。
 4 | 
 5 | ### 支持的中文标识符有
 6 | 
 7 | | 中文标识符 | 英文标识符 |
 8 | | ---------- | ---------- |
 9 | | 如果       | if         |
10 | | 那么       | then       |
11 | | 结束       | end        |
12 | | 否则       | else       |
13 | | 否则如果   | elseif     |
14 | | 循环       | while      |
15 | | 局部变量   | local      |
16 | | 返回       | return     |
17 | | 空         | nil        |
18 | | 真         | true       |
19 | | 假         | false      |
20 | | 不         | not        |
21 | | 没有       | not        |
22 | | 没         | not        |
23 | | 执行       | do         |
24 | | 且         | and        |
25 | | 或         | or         |
26 | | 定义函数   | function   |
27 | | 重复       | repeat     |
28 | | 直到       | until      |
29 | | 中断       | break      |
30 | 
31 | #### lua自带库函数对应如下
32 | 
33 | 全局函数
34 | 
35 | | 中文函数名 | lua函数名      |
36 | | ---------- | -------------- |
37 | | 垃圾回收   | collectgarbage |
38 | | 断言       | assert         |
39 | | 执行文件   | dofile         |
40 | | 错误       | error          |
41 | | 获取环境   | getfenv        |
42 | | 获取元表   | getmetatable   |
43 | | 数组迭代   | ipairs         |
44 | | 迭代       | pairs          |
45 | | 加载       | load           |
46 | | 加载文件   | loadfile       |
47 | | 加载字符串 | loadstring     |
48 | | 模块定义   | module         |
49 | | 下一个     | next           |
50 | | 调用       | pcall          |
51 | | 打印       | print          |
52 | | 原始相等   | rawequal       |
53 | | 原始获取   | rawget         |
54 | | 原始设置   | rawset         |
55 | | 包含文件   | require        |
56 | | 选择       | select         |
57 | | 设置环境   | setfenv        |
58 | | 设置元表   | setmetatable   |
59 | | 转为数字   | tonumber       |
60 | | 转为字符串 | tostring       |
61 | | 类型       | type           |
62 | | 拆开       | unpack         |
63 | | 保护调用   | xpcall         |
64 | 
65 | #### 示例
66 | 
67 | ```
68 | 局部变量 数字=12346
69 | 打印(数字)
70 | ```
71 | 
72 | 


--------------------------------------------------------------------------------
/lua52/lzio.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lzio.c,v 1.35.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Buffered streams
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #include <string.h>
 9 | 
10 | #define lzio_c
11 | #define LUA_CORE
12 | 
13 | #include "lua.h"
14 | 
15 | #include "llimits.h"
16 | #include "lmem.h"
17 | #include "lstate.h"
18 | #include "lzio.h"
19 | 
20 | 
21 | int luaZ_fill (ZIO *z) {
22 |   size_t size;
23 |   lua_State *L = z->L;
24 |   const char *buff;
25 |   lua_unlock(L);
26 |   buff = z->reader(L, z->data, &size);
27 |   lua_lock(L);
28 |   if (buff == NULL || size == 0)
29 |     return EOZ;
30 |   z->n = size - 1;  /* discount char being returned */
31 |   z->p = buff;
32 |   return cast_uchar(*(z->p++));
33 | }
34 | 
35 | 
36 | void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
37 |   z->L = L;
38 |   z->reader = reader;
39 |   z->data = data;
40 |   z->n = 0;
41 |   z->p = NULL;
42 | }
43 | 
44 | 
45 | /* --------------------------------------------------------------- read --- */
46 | size_t luaZ_read (ZIO *z, void *b, size_t n) {
47 |   while (n) {
48 |     size_t m;
49 |     if (z->n == 0) {  /* no bytes in buffer? */
50 |       if (luaZ_fill(z) == EOZ)  /* try to read more */
51 |         return n;  /* no more input; return number of missing bytes */
52 |       else {
53 |         z->n++;  /* luaZ_fill consumed first byte; put it back */
54 |         z->p--;
55 |       }
56 |     }
57 |     m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
58 |     memcpy(b, z->p, m);
59 |     z->n -= m;
60 |     z->p += m;
61 |     b = (char *)b + m;
62 |     n -= m;
63 |   }
64 |   return 0;
65 | }
66 | 
67 | /* ------------------------------------------------------------------------ */
68 | char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) {
69 |   if (n > buff->buffsize) {
70 |     if (n < LUA_MINBUFFER) n = LUA_MINBUFFER;
71 |     luaZ_resizebuffer(L, buff, n);
72 |   }
73 |   return buff->buffer;
74 | }
75 | 
76 | 
77 | 


--------------------------------------------------------------------------------
/lua51/ltm.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltm.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Tag methods
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #include <string.h>
 9 | 
10 | #define ltm_c
11 | #define LUA_CORE
12 | 
13 | #include "lua.h"
14 | 
15 | #include "lobject.h"
16 | #include "lstate.h"
17 | #include "lstring.h"
18 | #include "ltable.h"
19 | #include "ltm.h"
20 | 
21 | 
22 | 
23 | const char *const luaT_typenames[] = {
24 |   "nil", "boolean", "userdata", "number",
25 |   "string", "table", "function", "userdata", "thread",
26 |   "proto", "upval"
27 | };
28 | 
29 | 
30 | void luaT_init (lua_State *L) {
31 |   static const char *const luaT_eventname[] = {  /* ORDER TM */
32 |     "__index", "__newindex",
33 |     "__gc", "__mode", "__eq",
34 |     "__add", "__sub", "__mul", "__div", "__mod",
35 |     "__pow", "__unm", "__len", "__lt", "__le",
36 |     "__concat", "__call"
37 |   };
38 |   int i;
39 |   for (i=0; i<TM_N; i++) {
40 |     G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
41 |     luaS_fix(G(L)->tmname[i]);  /* never collect these names */
42 |   }
43 | }
44 | 
45 | 
46 | /*
47 | ** function to be used with macro "fasttm": optimized for absence of
48 | ** tag methods
49 | */
50 | const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
51 |   const TValue *tm = luaH_getstr(events, ename);
52 |   lua_assert(event <= TM_EQ);
53 |   if (ttisnil(tm)) {  /* no tag method? */
54 |     events->flags |= cast_byte(1u<<event);  /* cache this fact */
55 |     return NULL;
56 |   }
57 |   else return tm;
58 | }
59 | 
60 | 
61 | const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
62 |   Table *mt;
63 |   switch (ttype(o)) {
64 |     case LUA_TTABLE:
65 |       mt = hvalue(o)->metatable;
66 |       break;
67 |     case LUA_TUSERDATA:
68 |       mt = uvalue(o)->metatable;
69 |       break;
70 |     default:
71 |       mt = G(L)->mt[ttype(o)];
72 |   }
73 |   return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);
74 | }
75 | 
76 | 


--------------------------------------------------------------------------------
/lua52/linit.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: linit.c,v 1.32.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Initialization of libraries for lua.c and other clients
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | /*
 9 | ** If you embed Lua in your program and need to open the standard
10 | ** libraries, call luaL_openlibs in your program. If you need a
11 | ** different set of libraries, copy this file to your project and edit
12 | ** it to suit your needs.
13 | */
14 | 
15 | 
16 | #define linit_c
17 | #define LUA_LIB
18 | 
19 | #include "lua.h"
20 | 
21 | #include "lualib.h"
22 | #include "lauxlib.h"
23 | 
24 | 
25 | /*
26 | ** these libs are loaded by lua.c and are readily available to any Lua
27 | ** program
28 | */
29 | static const luaL_Reg loadedlibs[] = {
30 |   {"_G", luaopen_base},
31 |   {LUA_LOADLIBNAME, luaopen_package},
32 |   {LUA_COLIBNAME, luaopen_coroutine},
33 |   {LUA_TABLIBNAME, luaopen_table},
34 |   {LUA_IOLIBNAME, luaopen_io},
35 |   {LUA_OSLIBNAME, luaopen_os},
36 |   {LUA_STRLIBNAME, luaopen_string},
37 |   {LUA_BITLIBNAME, luaopen_bit32},
38 |   {LUA_MATHLIBNAME, luaopen_math},
39 |   {LUA_DBLIBNAME, luaopen_debug},
40 |   {NULL, NULL}
41 | };
42 | 
43 | 
44 | /*
45 | ** these libs are preloaded and must be required before used
46 | */
47 | static const luaL_Reg preloadedlibs[] = {
48 |   {NULL, NULL}
49 | };
50 | 
51 | 
52 | LUALIB_API void luaL_openlibs (lua_State *L) {
53 |   const luaL_Reg *lib;
54 |   /* call open functions from 'loadedlibs' and set results to global table */
55 |   for (lib = loadedlibs; lib->func; lib++) {
56 |     luaL_requiref(L, lib->name, lib->func, 1);
57 |     lua_pop(L, 1);  /* remove lib */
58 |   }
59 |   /* add open functions from 'preloadedlibs' into 'package.preload' table */
60 |   luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD");
61 |   for (lib = preloadedlibs; lib->func; lib++) {
62 |     lua_pushcfunction(L, lib->func);
63 |     lua_setfield(L, -2, lib->name);
64 |   }
65 |   lua_pop(L, 1);  /* remove _PRELOAD table */
66 | }
67 | 
68 | 


--------------------------------------------------------------------------------
/lua51/lzio.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lzio.c,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** a generic input stream interface
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #include <string.h>
 9 | 
10 | #define lzio_c
11 | #define LUA_CORE
12 | 
13 | #include "lua.h"
14 | 
15 | #include "llimits.h"
16 | #include "lmem.h"
17 | #include "lstate.h"
18 | #include "lzio.h"
19 | 
20 | 
21 | int luaZ_fill (ZIO *z) {
22 |   size_t size;
23 |   lua_State *L = z->L;
24 |   const char *buff;
25 |   lua_unlock(L);
26 |   buff = z->reader(L, z->data, &size);
27 |   lua_lock(L);
28 |   if (buff == NULL || size == 0) return EOZ;
29 |   z->n = size - 1;
30 |   z->p = buff;
31 |   return char2int(*(z->p++));
32 | }
33 | 
34 | 
35 | int luaZ_lookahead (ZIO *z) {
36 |   if (z->n == 0) {
37 |     if (luaZ_fill(z) == EOZ)
38 |       return EOZ;
39 |     else {
40 |       z->n++;  /* luaZ_fill removed first byte; put back it */
41 |       z->p--;
42 |     }
43 |   }
44 |   return char2int(*z->p);
45 | }
46 | 
47 | 
48 | void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
49 |   z->L = L;
50 |   z->reader = reader;
51 |   z->data = data;
52 |   z->n = 0;
53 |   z->p = NULL;
54 | }
55 | 
56 | 
57 | /* --------------------------------------------------------------- read --- */
58 | size_t luaZ_read (ZIO *z, void *b, size_t n) {
59 |   while (n) {
60 |     size_t m;
61 |     if (luaZ_lookahead(z) == EOZ)
62 |       return n;  /* return number of missing bytes */
63 |     m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
64 |     memcpy(b, z->p, m);
65 |     z->n -= m;
66 |     z->p += m;
67 |     b = (char *)b + m;
68 |     n -= m;
69 |   }
70 |   return 0;
71 | }
72 | 
73 | /* ------------------------------------------------------------------------ */
74 | char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) {
75 |   if (n > buff->buffsize) {
76 |     if (n < LUA_MINBUFFER) n = LUA_MINBUFFER;
77 |     luaZ_resizebuffer(L, buff, n);
78 |   }
79 |   return buff->buffer;
80 | }
81 | 
82 | 
83 | 


--------------------------------------------------------------------------------
/lua53/linit.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: linit.c,v 1.39.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Initialization of libraries for lua.c and other clients
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #define linit_c
 9 | #define LUA_LIB
10 | 
11 | /*
12 | ** If you embed Lua in your program and need to open the standard
13 | ** libraries, call luaL_openlibs in your program. If you need a
14 | ** different set of libraries, copy this file to your project and edit
15 | ** it to suit your needs.
16 | **
17 | ** You can also *preload* libraries, so that a later 'require' can
18 | ** open the library, which is already linked to the application.
19 | ** For that, do the following code:
20 | **
21 | **  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
22 | **  lua_pushcfunction(L, luaopen_modname);
23 | **  lua_setfield(L, -2, modname);
24 | **  lua_pop(L, 1);  // remove PRELOAD table
25 | */
26 | 
27 | #include "lprefix.h"
28 | 
29 | 
30 | #include <stddef.h>
31 | 
32 | #include "lua.h"
33 | 
34 | #include "lualib.h"
35 | #include "lauxlib.h"
36 | 
37 | 
38 | /*
39 | ** these libs are loaded by lua.c and are readily available to any Lua
40 | ** program
41 | */
42 | static const luaL_Reg loadedlibs[] = {
43 |   {"_G", luaopen_base},
44 |   {LUA_LOADLIBNAME, luaopen_package},
45 |   {LUA_COLIBNAME, luaopen_coroutine},
46 |   {LUA_TABLIBNAME, luaopen_table},
47 |   {LUA_IOLIBNAME, luaopen_io},
48 |   {LUA_OSLIBNAME, luaopen_os},
49 |   {LUA_STRLIBNAME, luaopen_string},
50 |   {LUA_MATHLIBNAME, luaopen_math},
51 |   {LUA_UTF8LIBNAME, luaopen_utf8},
52 |   {LUA_DBLIBNAME, luaopen_debug},
53 | #if defined(LUA_COMPAT_BITLIB)
54 |   {LUA_BITLIBNAME, luaopen_bit32},
55 | #endif
56 |   {NULL, NULL}
57 | };
58 | 
59 | 
60 | LUALIB_API void luaL_openlibs (lua_State *L) {
61 |   const luaL_Reg *lib;
62 |   /* "require" functions from 'loadedlibs' and set results to global table */
63 |   for (lib = loadedlibs; lib->func; lib++) {
64 |     luaL_requiref(L, lib->name, lib->func, 1);
65 |     lua_pop(L, 1);  /* remove lib */
66 |   }
67 | }
68 | 
69 | 


--------------------------------------------------------------------------------
/lua52/lmem.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lmem.h,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Interface to Memory Manager
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lmem_h
 8 | #define lmem_h
 9 | 
10 | 
11 | #include <stddef.h>
12 | 
13 | #include "llimits.h"
14 | #include "lua.h"
15 | 
16 | 
17 | /*
18 | ** This macro avoids the runtime division MAX_SIZET/(e), as 'e' is
19 | ** always constant.
20 | ** The macro is somewhat complex to avoid warnings:
21 | ** +1 avoids warnings of "comparison has constant result";
22 | ** cast to 'void' avoids warnings of "value unused".
23 | */
24 | #define luaM_reallocv(L,b,on,n,e) \
25 |   (cast(void, \
26 |      (cast(size_t, (n)+1) > MAX_SIZET/(e)) ? (luaM_toobig(L), 0) : 0), \
27 |    luaM_realloc_(L, (b), (on)*(e), (n)*(e)))
28 | 
29 | #define luaM_freemem(L, b, s)	luaM_realloc_(L, (b), (s), 0)
30 | #define luaM_free(L, b)		luaM_realloc_(L, (b), sizeof(*(b)), 0)
31 | #define luaM_freearray(L, b, n)   luaM_reallocv(L, (b), n, 0, sizeof((b)[0]))
32 | 
33 | #define luaM_malloc(L,s)	luaM_realloc_(L, NULL, 0, (s))
34 | #define luaM_new(L,t)		cast(t *, luaM_malloc(L, sizeof(t)))
35 | #define luaM_newvector(L,n,t) \
36 | 		cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
37 | 
38 | #define luaM_newobject(L,tag,s)	luaM_realloc_(L, NULL, tag, (s))
39 | 
40 | #define luaM_growvector(L,v,nelems,size,t,limit,e) \
41 |           if ((nelems)+1 > (size)) \
42 |             ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
43 | 
44 | #define luaM_reallocvector(L, v,oldn,n,t) \
45 |    ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
46 | 
47 | LUAI_FUNC l_noret luaM_toobig (lua_State *L);
48 | 
49 | /* not to be called directly */
50 | LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
51 |                                                           size_t size);
52 | LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
53 |                                size_t size_elem, int limit,
54 |                                const char *what);
55 | 
56 | #endif
57 | 
58 | 


--------------------------------------------------------------------------------
/lua53/ltm.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltm.h,v 2.22.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Tag methods
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ltm_h
 8 | #define ltm_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | 
13 | 
14 | /*
15 | * WARNING: if you change the order of this enumeration,
16 | * grep "ORDER TM" and "ORDER OP"
17 | */
18 | typedef enum {
19 |   TM_INDEX,
20 |   TM_NEWINDEX,
21 |   TM_GC,
22 |   TM_MODE,
23 |   TM_LEN,
24 |   TM_EQ,  /* last tag method with fast access */
25 |   TM_ADD,
26 |   TM_SUB,
27 |   TM_MUL,
28 |   TM_MOD,
29 |   TM_POW,
30 |   TM_DIV,
31 |   TM_IDIV,
32 |   TM_BAND,
33 |   TM_BOR,
34 |   TM_BXOR,
35 |   TM_SHL,
36 |   TM_SHR,
37 |   TM_UNM,
38 |   TM_BNOT,
39 |   TM_LT,
40 |   TM_LE,
41 |   TM_CONCAT,
42 |   TM_CALL,
43 |   TM_N		/* number of elements in the enum */
44 | } TMS;
45 | 
46 | 
47 | 
48 | #define gfasttm(g,et,e) ((et) == NULL ? NULL : \
49 |   ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
50 | 
51 | #define fasttm(l,et,e)	gfasttm(G(l), et, e)
52 | 
53 | #define ttypename(x)	luaT_typenames_[(x) + 1]
54 | 
55 | LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS];
56 | 
57 | 
58 | LUAI_FUNC const char *luaT_objtypename (lua_State *L, const TValue *o);
59 | 
60 | LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);
61 | LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
62 |                                                        TMS event);
63 | LUAI_FUNC void luaT_init (lua_State *L);
64 | 
65 | LUAI_FUNC void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
66 |                             const TValue *p2, TValue *p3, int hasres);
67 | LUAI_FUNC int luaT_callbinTM (lua_State *L, const TValue *p1, const TValue *p2,
68 |                               StkId res, TMS event);
69 | LUAI_FUNC void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
70 |                               StkId res, TMS event);
71 | LUAI_FUNC int luaT_callorderTM (lua_State *L, const TValue *p1,
72 |                                 const TValue *p2, TMS event);
73 | 
74 | 
75 | 
76 | #endif
77 | 


--------------------------------------------------------------------------------
/lua51/ldo.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ldo.h,v 2.7.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Stack and Call structure of Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ldo_h
 8 | #define ldo_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | #include "lstate.h"
13 | #include "lzio.h"
14 | 
15 | 
16 | #define luaD_checkstack(L,n)	\
17 |   if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \
18 |     luaD_growstack(L, n); \
19 |   else condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1));
20 | 
21 | 
22 | #define incr_top(L) {luaD_checkstack(L,1); L->top++;}
23 | 
24 | #define savestack(L,p)		((char *)(p) - (char *)L->stack)
25 | #define restorestack(L,n)	((TValue *)((char *)L->stack + (n)))
26 | 
27 | #define saveci(L,p)		((char *)(p) - (char *)L->base_ci)
28 | #define restoreci(L,n)		((CallInfo *)((char *)L->base_ci + (n)))
29 | 
30 | 
31 | /* results from luaD_precall */
32 | #define PCRLUA		0	/* initiated a call to a Lua function */
33 | #define PCRC		1	/* did a call to a C function */
34 | #define PCRYIELD	2	/* C funtion yielded */
35 | 
36 | 
37 | /* type of protected functions, to be ran by `runprotected' */
38 | typedef void (*Pfunc) (lua_State *L, void *ud);
39 | 
40 | LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name);
41 | LUAI_FUNC void luaD_callhook (lua_State *L, int event, int line);
42 | LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
43 | LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
44 | LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
45 |                                         ptrdiff_t oldtop, ptrdiff_t ef);
46 | LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);
47 | LUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize);
48 | LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
49 | LUAI_FUNC void luaD_growstack (lua_State *L, int n);
50 | 
51 | LUAI_FUNC void luaD_throw (lua_State *L, int errcode);
52 | LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
53 | 
54 | LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
55 | 
56 | #endif
57 | 
58 | 


--------------------------------------------------------------------------------
/lua52/ltm.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltm.c,v 2.14.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Tag methods
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #include <string.h>
 9 | 
10 | #define ltm_c
11 | #define LUA_CORE
12 | 
13 | #include "lua.h"
14 | 
15 | #include "lobject.h"
16 | #include "lstate.h"
17 | #include "lstring.h"
18 | #include "ltable.h"
19 | #include "ltm.h"
20 | 
21 | 
22 | static const char udatatypename[] = "userdata";
23 | 
24 | LUAI_DDEF const char *const luaT_typenames_[LUA_TOTALTAGS] = {
25 |   "no value",
26 |   "nil", "boolean", udatatypename, "number",
27 |   "string", "table", "function", udatatypename, "thread",
28 |   "proto", "upval"  /* these last two cases are used for tests only */
29 | };
30 | 
31 | 
32 | void luaT_init (lua_State *L) {
33 |   static const char *const luaT_eventname[] = {  /* ORDER TM */
34 |     "__index", "__newindex",
35 |     "__gc", "__mode", "__len", "__eq",
36 |     "__add", "__sub", "__mul", "__div", "__mod",
37 |     "__pow", "__unm", "__lt", "__le",
38 |     "__concat", "__call"
39 |   };
40 |   int i;
41 |   for (i=0; i<TM_N; i++) {
42 |     G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
43 |     luaS_fix(G(L)->tmname[i]);  /* never collect these names */
44 |   }
45 | }
46 | 
47 | 
48 | /*
49 | ** function to be used with macro "fasttm": optimized for absence of
50 | ** tag methods
51 | */
52 | const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
53 |   const TValue *tm = luaH_getstr(events, ename);
54 |   lua_assert(event <= TM_EQ);
55 |   if (ttisnil(tm)) {  /* no tag method? */
56 |     events->flags |= cast_byte(1u<<event);  /* cache this fact */
57 |     return NULL;
58 |   }
59 |   else return tm;
60 | }
61 | 
62 | 
63 | const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
64 |   Table *mt;
65 |   switch (ttypenv(o)) {
66 |     case LUA_TTABLE:
67 |       mt = hvalue(o)->metatable;
68 |       break;
69 |     case LUA_TUSERDATA:
70 |       mt = uvalue(o)->metatable;
71 |       break;
72 |     default:
73 |       mt = G(L)->mt[ttypenv(o)];
74 |   }
75 |   return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);
76 | }
77 | 
78 | 


--------------------------------------------------------------------------------
/premake5.lua:
--------------------------------------------------------------------------------
 1 | 
 2 | solution "LuaChinese"
 3 | 	location ( "build" )
 4 | 	targetdir("build")
 5 | 	configurations { "Debug", "Release" }
 6 | 	defines { "_CRT_SECURE_NO_WARNINGS" }
 7 | 	characterset ("MBCS")
 8 | 	
 9 | 	configuration "Debug"
10 | 		defines { "DEBUG" }
11 | 		flags { "Symbols", "ExtraWarnings"}
12 | 
13 | 	configuration "Release"
14 | 		defines { "NDEBUG" }
15 | 		flags { "Optimize", "ExtraWarnings"}			
16 | 	
17 | 	
18 |    	project "lualib51"
19 | 		language "C++"
20 | 		kind "StaticLib"
21 | 		includedirs { "lua51","./" }
22 | 		files { "lua51/*.h","lua51/*.c","lua51/*.cpp","lconvert.*" }
23 | 		removefiles {"lua51/luac.c","lua51/lua.c"}
24 | 		
25 | 	project "lua51"
26 | 		kind "ConsoleApp"
27 | 		language "C++"
28 | 		includedirs { "lua51" }
29 | 		files { "lua51/lua.c" }
30 | 		links { "lualib51"}	
31 | 			
32 | 	project "luac51"
33 | 		kind "ConsoleApp"
34 | 		language "C++"
35 | 		includedirs { "lua51" }
36 | 		files { "lua51/luac.c" }
37 | 		links { "lualib51"}	
38 | 
39 |    	project "lualib52"
40 | 		language "C++"
41 | 		kind "StaticLib"
42 | 		includedirs { "lua52","./" }
43 | 		files { "lua52/*.h","lua52/*.c","lua52/*.cpp","lconvert.*" }
44 | 		removefiles {"lua52/luac.c","lua52/lua.c"}
45 | 
46 | 	project "lua52"
47 | 		kind "ConsoleApp"
48 | 		language "C++"
49 | 		includedirs { "lua52" }
50 | 		files { "lua52/lua.c" }
51 | 		links { "lualib52"}	
52 | 			
53 | 	project "luac52"
54 | 		kind "ConsoleApp"
55 | 		language "C++"
56 | 		includedirs { "lua52" }
57 | 		files { "lua52/luac.c" }
58 | 		links { "lualib52"}	
59 | 		
60 | 		
61 |    	project "lualib53"
62 | 		language "C++"
63 | 		kind "StaticLib"
64 | 		includedirs { "lua53","./" }
65 | 		files { "lua53/*.h","lua53/*.c","lua53/*.cpp","lconvert.*" }
66 | 		removefiles {"lua53/luac.c","lua53/lua.c"}
67 | 
68 | 	project "lua53"
69 | 		kind "ConsoleApp"
70 | 		language "C++"
71 | 		includedirs { "lua53" }
72 | 		files { "lua53/lua.c" }
73 | 		links { "lualib53"}	
74 | 			
75 | 	project "luac53"
76 | 		kind "ConsoleApp"
77 | 		language "C++"
78 | 		includedirs { "lua53" }
79 | 		files { "lua53/luac.c" }
80 | 		links { "lualib53"}		
81 | 		
82 | 		
83 | 	project "convert"
84 | 		kind "ConsoleApp"
85 | 		language "C++"
86 | 		files { "convert.cpp","lconvert.*" }		
87 | 			
88 | 
89 | 
90 | 
91 | 


--------------------------------------------------------------------------------
/lua52/lctype.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** 'ctype' functions for Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lctype_h
 8 | #define lctype_h
 9 | 
10 | #include "lua.h"
11 | 
12 | 
13 | /*
14 | ** WARNING: the functions defined here do not necessarily correspond
15 | ** to the similar functions in the standard C ctype.h. They are
16 | ** optimized for the specific needs of Lua
17 | */
18 | 
19 | #if !defined(LUA_USE_CTYPE)
20 | 
21 | #if 'A' == 65 && '0' == 48
22 | /* ASCII case: can use its own tables; faster and fixed */
23 | #define LUA_USE_CTYPE	0
24 | #else
25 | /* must use standard C ctype */
26 | #define LUA_USE_CTYPE	1
27 | #endif
28 | 
29 | #endif
30 | 
31 | 
32 | #if !LUA_USE_CTYPE	/* { */
33 | 
34 | #include <limits.h>
35 | 
36 | #include "llimits.h"
37 | 
38 | 
39 | #define ALPHABIT	0
40 | #define DIGITBIT	1
41 | #define PRINTBIT	2
42 | #define SPACEBIT	3
43 | #define XDIGITBIT	4
44 | 
45 | 
46 | #define MASK(B)		(1 << (B))
47 | 
48 | 
49 | /*
50 | ** add 1 to char to allow index -1 (EOZ)
51 | */
52 | #define testprop(c,p)	(luai_ctype_[(c)+1] & (p))
53 | 
54 | /*
55 | ** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
56 | */
57 | #define lislalpha(c)	testprop(c, MASK(ALPHABIT))
58 | #define lislalnum(c)	testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
59 | #define lisdigit(c)	testprop(c, MASK(DIGITBIT))
60 | #define lisspace(c)	testprop(c, MASK(SPACEBIT))
61 | #define lisprint(c)	testprop(c, MASK(PRINTBIT))
62 | #define lisxdigit(c)	testprop(c, MASK(XDIGITBIT))
63 | 
64 | /*
65 | ** this 'ltolower' only works for alphabetic characters
66 | */
67 | #define ltolower(c)	((c) | ('A' ^ 'a'))
68 | 
69 | 
70 | /* two more entries for 0 and -1 (EOZ) */
71 | LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
72 | 
73 | 
74 | #else			/* }{ */
75 | 
76 | /*
77 | ** use standard C ctypes
78 | */
79 | 
80 | #include <ctype.h>
81 | 
82 | 
83 | #define lislalpha(c)	(isalpha(c) || (c) == '_')
84 | #define lislalnum(c)	(isalnum(c) || (c) == '_')
85 | #define lisdigit(c)	(isdigit(c))
86 | #define lisspace(c)	(isspace(c))
87 | #define lisprint(c)	(isprint(c))
88 | #define lisxdigit(c)	(isxdigit(c))
89 | 
90 | #define ltolower(c)	(tolower(c))
91 | 
92 | #endif			/* } */
93 | 
94 | #endif
95 | 
96 | 


--------------------------------------------------------------------------------
/lua53/lctype.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** 'ctype' functions for Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lctype_h
 8 | #define lctype_h
 9 | 
10 | #include "lua.h"
11 | 
12 | 
13 | /*
14 | ** WARNING: the functions defined here do not necessarily correspond
15 | ** to the similar functions in the standard C ctype.h. They are
16 | ** optimized for the specific needs of Lua
17 | */
18 | 
19 | #if !defined(LUA_USE_CTYPE)
20 | 
21 | #if 'A' == 65 && '0' == 48
22 | /* ASCII case: can use its own tables; faster and fixed */
23 | #define LUA_USE_CTYPE	0
24 | #else
25 | /* must use standard C ctype */
26 | #define LUA_USE_CTYPE	1
27 | #endif
28 | 
29 | #endif
30 | 
31 | 
32 | #if !LUA_USE_CTYPE	/* { */
33 | 
34 | #include <limits.h>
35 | 
36 | #include "llimits.h"
37 | 
38 | 
39 | #define ALPHABIT	0
40 | #define DIGITBIT	1
41 | #define PRINTBIT	2
42 | #define SPACEBIT	3
43 | #define XDIGITBIT	4
44 | 
45 | 
46 | #define MASK(B)		(1 << (B))
47 | 
48 | 
49 | /*
50 | ** add 1 to char to allow index -1 (EOZ)
51 | */
52 | #define testprop(c,p)	(luai_ctype_[(c)+1] & (p))
53 | 
54 | /*
55 | ** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
56 | */
57 | #define lislalpha(c)	testprop(c, MASK(ALPHABIT))
58 | #define lislalnum(c)	testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
59 | #define lisdigit(c)	testprop(c, MASK(DIGITBIT))
60 | #define lisspace(c)	testprop(c, MASK(SPACEBIT))
61 | #define lisprint(c)	testprop(c, MASK(PRINTBIT))
62 | #define lisxdigit(c)	testprop(c, MASK(XDIGITBIT))
63 | 
64 | /*
65 | ** this 'ltolower' only works for alphabetic characters
66 | */
67 | #define ltolower(c)	((c) | ('A' ^ 'a'))
68 | 
69 | 
70 | /* two more entries for 0 and -1 (EOZ) */
71 | LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
72 | 
73 | 
74 | #else			/* }{ */
75 | 
76 | /*
77 | ** use standard C ctypes
78 | */
79 | 
80 | #include <ctype.h>
81 | 
82 | 
83 | #define lislalpha(c)	(isalpha(c) || (c) == '_')
84 | #define lislalnum(c)	(isalnum(c) || (c) == '_')
85 | #define lisdigit(c)	(isdigit(c))
86 | #define lisspace(c)	(isspace(c))
87 | #define lisprint(c)	(isprint(c))
88 | #define lisxdigit(c)	(isxdigit(c))
89 | 
90 | #define ltolower(c)	(tolower(c))
91 | 
92 | #endif			/* } */
93 | 
94 | #endif
95 | 
96 | 


--------------------------------------------------------------------------------
/lua53/ldo.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ldo.h,v 2.29.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Stack and Call structure of Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ldo_h
 8 | #define ldo_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | #include "lstate.h"
13 | #include "lzio.h"
14 | 
15 | 
16 | /*
17 | ** Macro to check stack size and grow stack if needed.  Parameters
18 | ** 'pre'/'pos' allow the macro to preserve a pointer into the
19 | ** stack across reallocations, doing the work only when needed.
20 | ** 'condmovestack' is used in heavy tests to force a stack reallocation
21 | ** at every check.
22 | */
23 | #define luaD_checkstackaux(L,n,pre,pos)  \
24 | 	if (L->stack_last - L->top <= (n)) \
25 | 	  { pre; luaD_growstack(L, n); pos; } else { condmovestack(L,pre,pos); }
26 | 
27 | /* In general, 'pre'/'pos' are empty (nothing to save) */
28 | #define luaD_checkstack(L,n)	luaD_checkstackaux(L,n,(void)0,(void)0)
29 | 
30 | 
31 | 
32 | #define savestack(L,p)		((char *)(p) - (char *)L->stack)
33 | #define restorestack(L,n)	((TValue *)((char *)L->stack + (n)))
34 | 
35 | 
36 | /* type of protected functions, to be ran by 'runprotected' */
37 | typedef void (*Pfunc) (lua_State *L, void *ud);
38 | 
39 | LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
40 |                                                   const char *mode);
41 | LUAI_FUNC void luaD_hook (lua_State *L, int event, int line);
42 | LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
43 | LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
44 | LUAI_FUNC void luaD_callnoyield (lua_State *L, StkId func, int nResults);
45 | LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
46 |                                         ptrdiff_t oldtop, ptrdiff_t ef);
47 | LUAI_FUNC int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult,
48 |                                           int nres);
49 | LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
50 | LUAI_FUNC void luaD_growstack (lua_State *L, int n);
51 | LUAI_FUNC void luaD_shrinkstack (lua_State *L);
52 | LUAI_FUNC void luaD_inctop (lua_State *L);
53 | 
54 | LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
55 | LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
56 | 
57 | #endif
58 | 
59 | 


--------------------------------------------------------------------------------
/lua53/ltable.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltable.h,v 2.23.1.2 2018/05/24 19:39:05 roberto Exp $
 3 | ** Lua tables (hash)
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ltable_h
 8 | #define ltable_h
 9 | 
10 | #include "lobject.h"
11 | 
12 | 
13 | #define gnode(t,i)	(&(t)->node[i])
14 | #define gval(n)		(&(n)->i_val)
15 | #define gnext(n)	((n)->i_key.nk.next)
16 | 
17 | 
18 | /* 'const' to avoid wrong writings that can mess up field 'next' */
19 | #define gkey(n)		cast(const TValue*, (&(n)->i_key.tvk))
20 | 
21 | /*
22 | ** writable version of 'gkey'; allows updates to individual fields,
23 | ** but not to the whole (which has incompatible type)
24 | */
25 | #define wgkey(n)		(&(n)->i_key.nk)
26 | 
27 | #define invalidateTMcache(t)	((t)->flags = 0)
28 | 
29 | 
30 | /* true when 't' is using 'dummynode' as its hash part */
31 | #define isdummy(t)		((t)->lastfree == NULL)
32 | 
33 | 
34 | /* allocated size for hash nodes */
35 | #define allocsizenode(t)	(isdummy(t) ? 0 : sizenode(t))
36 | 
37 | 
38 | /* returns the key, given the value of a table entry */
39 | #define keyfromval(v) \
40 |   (gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val))))
41 | 
42 | 
43 | LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key);
44 | LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key,
45 |                                                     TValue *value);
46 | LUAI_FUNC const TValue *luaH_getshortstr (Table *t, TString *key);
47 | LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
48 | LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
49 | LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key);
50 | LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key);
51 | LUAI_FUNC Table *luaH_new (lua_State *L);
52 | LUAI_FUNC void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
53 |                                                     unsigned int nhsize);
54 | LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize);
55 | LUAI_FUNC void luaH_free (lua_State *L, Table *t);
56 | LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
57 | LUAI_FUNC lua_Unsigned luaH_getn (Table *t);
58 | 
59 | 
60 | #if defined(LUA_DEBUG)
61 | LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
62 | LUAI_FUNC int luaH_isdummy (const Table *t);
63 | #endif
64 | 
65 | 
66 | #endif
67 | 


--------------------------------------------------------------------------------
/lua52/llex.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: llex.h,v 1.72.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Lexical Analyzer
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef llex_h
 8 | #define llex_h
 9 | 
10 | #include "lobject.h"
11 | #include "lzio.h"
12 | 
13 | 
14 | #define FIRST_RESERVED	257
15 | 
16 | 
17 | 
18 | /*
19 | * WARNING: if you change the order of this enumeration,
20 | * grep "ORDER RESERVED"
21 | */
22 | enum RESERVED {
23 |   /* terminal symbols denoted by reserved words */
24 |   TK_AND = FIRST_RESERVED, TK_BREAK,
25 |   TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
26 |   TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
27 |   TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
28 |   /* other terminal symbols */
29 |   TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_DBCOLON, TK_EOS,
30 |   TK_NUMBER, TK_NAME, TK_STRING
31 | };
32 | 
33 | /* number of reserved words */
34 | #define NUM_RESERVED	(cast(int, TK_WHILE-FIRST_RESERVED+1))
35 | 
36 | 
37 | typedef union {
38 |   lua_Number r;
39 |   TString *ts;
40 | } SemInfo;  /* semantics information */
41 | 
42 | 
43 | typedef struct Token {
44 |   int token;
45 |   SemInfo seminfo;
46 | } Token;
47 | 
48 | 
49 | /* state of the lexer plus state of the parser when shared by all
50 |    functions */
51 | typedef struct LexState {
52 |   int current;  /* current character (charint) */
53 |   int linenumber;  /* input line counter */
54 |   int lastline;  /* line of last token `consumed' */
55 |   Token t;  /* current token */
56 |   Token lookahead;  /* look ahead token */
57 |   struct FuncState *fs;  /* current function (parser) */
58 |   struct lua_State *L;
59 |   ZIO *z;  /* input stream */
60 |   Mbuffer *buff;  /* buffer for tokens */
61 |   struct Dyndata *dyd;  /* dynamic structures used by the parser */
62 |   TString *source;  /* current source name */
63 |   TString *envn;  /* environment variable name */
64 |   char decpoint;  /* locale decimal point */
65 | } LexState;
66 | 
67 | 
68 | LUAI_FUNC void luaX_init (lua_State *L);
69 | LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
70 |                               TString *source, int firstchar);
71 | LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
72 | LUAI_FUNC void luaX_next (LexState *ls);
73 | LUAI_FUNC int luaX_lookahead (LexState *ls);
74 | LUAI_FUNC l_noret luaX_syntaxerror (LexState *ls, const char *s);
75 | LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
76 | 
77 | 
78 | #endif
79 | 


--------------------------------------------------------------------------------
/lua52/lctype.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lctype.c,v 1.11.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** 'ctype' functions for Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #define lctype_c
 8 | #define LUA_CORE
 9 | 
10 | #include "lctype.h"
11 | 
12 | #if !LUA_USE_CTYPE	/* { */
13 | 
14 | #include <limits.h>
15 | 
16 | LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
17 |   0x00,  /* EOZ */
18 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 0. */
19 |   0x00,  0x08,  0x08,  0x08,  0x08,  0x08,  0x00,  0x00,
20 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 1. */
21 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
22 |   0x0c,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,	/* 2. */
23 |   0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
24 |   0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,	/* 3. */
25 |   0x16,  0x16,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
26 |   0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 4. */
27 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
28 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 5. */
29 |   0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x05,
30 |   0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 6. */
31 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
32 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 7. */
33 |   0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x00,
34 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 8. */
35 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
36 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 9. */
37 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
38 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* a. */
39 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
40 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* b. */
41 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
42 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* c. */
43 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
44 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* d. */
45 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
46 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* e. */
47 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
48 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* f. */
49 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
50 | };
51 | 
52 | #endif			/* } */
53 | 


--------------------------------------------------------------------------------
/lua51/llex.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: llex.h,v 1.58.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Lexical Analyzer
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef llex_h
 8 | #define llex_h
 9 | 
10 | #include "lobject.h"
11 | #include "lzio.h"
12 | 
13 | 
14 | #define FIRST_RESERVED	257
15 | 
16 | /* maximum length of a reserved word */
17 | #define TOKEN_LEN	(sizeof("function")/sizeof(char))
18 | 
19 | 
20 | /*
21 | * WARNING: if you change the order of this enumeration,
22 | * grep "ORDER RESERVED"
23 | */
24 | enum RESERVED {
25 |   /* terminal symbols denoted by reserved words */
26 |   TK_AND = FIRST_RESERVED, TK_BREAK,
27 |   TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
28 |   TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
29 |   TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
30 |   /* other terminal symbols */
31 |   TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER,
32 |   TK_NAME, TK_STRING, TK_EOS
33 | };
34 | 
35 | /* number of reserved words */
36 | #define NUM_RESERVED	(cast(int, TK_WHILE-FIRST_RESERVED+1))
37 | 
38 | 
39 | /* array with token `names' */
40 | LUAI_DATA const char *const luaX_tokens [];
41 | 
42 | 
43 | typedef union {
44 |   lua_Number r;
45 |   TString *ts;
46 | } SemInfo;  /* semantics information */
47 | 
48 | 
49 | typedef struct Token {
50 |   int token;
51 |   SemInfo seminfo;
52 | } Token;
53 | 
54 | 
55 | typedef struct LexState {
56 |   int current;  /* current character (charint) */
57 |   int linenumber;  /* input line counter */
58 |   int lastline;  /* line of last token `consumed' */
59 |   Token t;  /* current token */
60 |   Token lookahead;  /* look ahead token */
61 |   struct FuncState *fs;  /* `FuncState' is private to the parser */
62 |   struct lua_State *L;
63 |   ZIO *z;  /* input stream */
64 |   Mbuffer *buff;  /* buffer for tokens */
65 |   TString *source;  /* current source name */
66 |   char decpoint;  /* locale decimal point */
67 | } LexState;
68 | 
69 | 
70 | LUAI_FUNC void luaX_init (lua_State *L);
71 | LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
72 |                               TString *source);
73 | LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
74 | LUAI_FUNC void luaX_next (LexState *ls);
75 | LUAI_FUNC void luaX_lookahead (LexState *ls);
76 | LUAI_FUNC void luaX_lexerror (LexState *ls, const char *msg, int token);
77 | LUAI_FUNC void luaX_syntaxerror (LexState *ls, const char *s);
78 | LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
79 | 
80 | 
81 | #endif
82 | 


--------------------------------------------------------------------------------
/lua53/lctype.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lctype.c,v 1.12.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** 'ctype' functions for Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #define lctype_c
 8 | #define LUA_CORE
 9 | 
10 | #include "lprefix.h"
11 | 
12 | 
13 | #include "lctype.h"
14 | 
15 | #if !LUA_USE_CTYPE	/* { */
16 | 
17 | #include <limits.h>
18 | 
19 | LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
20 |   0x00,  /* EOZ */
21 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 0. */
22 |   0x00,  0x08,  0x08,  0x08,  0x08,  0x08,  0x00,  0x00,
23 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 1. */
24 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
25 |   0x0c,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,	/* 2. */
26 |   0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
27 |   0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,	/* 3. */
28 |   0x16,  0x16,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
29 |   0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 4. */
30 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
31 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 5. */
32 |   0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x05,
33 |   0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 6. */
34 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
35 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 7. */
36 |   0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x00,
37 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 8. */
38 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
39 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 9. */
40 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
41 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* a. */
42 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
43 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* b. */
44 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
45 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* c. */
46 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
47 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* d. */
48 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
49 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* e. */
50 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
51 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* f. */
52 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
53 | };
54 | 
55 | #endif			/* } */
56 | 


--------------------------------------------------------------------------------
/lua51/lmem.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lmem.c,v 1.70.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Interface to Memory Manager
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #include <stddef.h>
 9 | 
10 | #define lmem_c
11 | #define LUA_CORE
12 | 
13 | #include "lua.h"
14 | 
15 | #include "ldebug.h"
16 | #include "ldo.h"
17 | #include "lmem.h"
18 | #include "lobject.h"
19 | #include "lstate.h"
20 | 
21 | 
22 | 
23 | /*
24 | ** About the realloc function:
25 | ** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
26 | ** (`osize' is the old size, `nsize' is the new size)
27 | **
28 | ** Lua ensures that (ptr == NULL) iff (osize == 0).
29 | **
30 | ** * frealloc(ud, NULL, 0, x) creates a new block of size `x'
31 | **
32 | ** * frealloc(ud, p, x, 0) frees the block `p'
33 | ** (in this specific case, frealloc must return NULL).
34 | ** particularly, frealloc(ud, NULL, 0, 0) does nothing
35 | ** (which is equivalent to free(NULL) in ANSI C)
36 | **
37 | ** frealloc returns NULL if it cannot create or reallocate the area
38 | ** (any reallocation to an equal or smaller size cannot fail!)
39 | */
40 | 
41 | 
42 | 
43 | #define MINSIZEARRAY	4
44 | 
45 | 
46 | void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
47 |                      int limit, const char *errormsg) {
48 |   void *newblock;
49 |   int newsize;
50 |   if (*size >= limit/2) {  /* cannot double it? */
51 |     if (*size >= limit)  /* cannot grow even a little? */
52 |       luaG_runerror(L, errormsg);
53 |     newsize = limit;  /* still have at least one free place */
54 |   }
55 |   else {
56 |     newsize = (*size)*2;
57 |     if (newsize < MINSIZEARRAY)
58 |       newsize = MINSIZEARRAY;  /* minimum size */
59 |   }
60 |   newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
61 |   *size = newsize;  /* update only when everything else is OK */
62 |   return newblock;
63 | }
64 | 
65 | 
66 | void *luaM_toobig (lua_State *L) {
67 |   luaG_runerror(L, "memory allocation error: block too big");
68 |   return NULL;  /* to avoid warnings */
69 | }
70 | 
71 | 
72 | 
73 | /*
74 | ** generic allocation routine.
75 | */
76 | void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
77 |   global_State *g = G(L);
78 |   lua_assert((osize == 0) == (block == NULL));
79 |   block = (*g->frealloc)(g->ud, block, osize, nsize);
80 |   if (block == NULL && nsize > 0)
81 |     luaD_throw(L, LUA_ERRMEM);
82 |   lua_assert((nsize == 0) == (block == NULL));
83 |   g->totalbytes = (g->totalbytes - osize) + nsize;
84 |   return block;
85 | }
86 | 
87 | 


--------------------------------------------------------------------------------
/lua51/lparser.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lparser.h,v 1.57.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Lua Parser
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lparser_h
 8 | #define lparser_h
 9 | 
10 | #include "llimits.h"
11 | #include "lobject.h"
12 | #include "lzio.h"
13 | 
14 | 
15 | /*
16 | ** Expression descriptor
17 | */
18 | 
19 | typedef enum {
20 |   VVOID,	/* no value */
21 |   VNIL,
22 |   VTRUE,
23 |   VFALSE,
24 |   VK,		/* info = index of constant in `k' */
25 |   VKNUM,	/* nval = numerical value */
26 |   VLOCAL,	/* info = local register */
27 |   VUPVAL,       /* info = index of upvalue in `upvalues' */
28 |   VGLOBAL,	/* info = index of table; aux = index of global name in `k' */
29 |   VINDEXED,	/* info = table register; aux = index register (or `k') */
30 |   VJMP,		/* info = instruction pc */
31 |   VRELOCABLE,	/* info = instruction pc */
32 |   VNONRELOC,	/* info = result register */
33 |   VCALL,	/* info = instruction pc */
34 |   VVARARG	/* info = instruction pc */
35 | } expkind;
36 | 
37 | typedef struct expdesc {
38 |   expkind k;
39 |   union {
40 |     struct { int info, aux; } s;
41 |     lua_Number nval;
42 |   } u;
43 |   int t;  /* patch list of `exit when true' */
44 |   int f;  /* patch list of `exit when false' */
45 | } expdesc;
46 | 
47 | 
48 | typedef struct upvaldesc {
49 |   lu_byte k;
50 |   lu_byte info;
51 | } upvaldesc;
52 | 
53 | 
54 | struct BlockCnt;  /* defined in lparser.c */
55 | 
56 | 
57 | /* state needed to generate code for a given function */
58 | typedef struct FuncState {
59 |   Proto *f;  /* current function header */
60 |   Table *h;  /* table to find (and reuse) elements in `k' */
61 |   struct FuncState *prev;  /* enclosing function */
62 |   struct LexState *ls;  /* lexical state */
63 |   struct lua_State *L;  /* copy of the Lua state */
64 |   struct BlockCnt *bl;  /* chain of current blocks */
65 |   int pc;  /* next position to code (equivalent to `ncode') */
66 |   int lasttarget;   /* `pc' of last `jump target' */
67 |   int jpc;  /* list of pending jumps to `pc' */
68 |   int freereg;  /* first free register */
69 |   int nk;  /* number of elements in `k' */
70 |   int np;  /* number of elements in `p' */
71 |   short nlocvars;  /* number of elements in `locvars' */
72 |   lu_byte nactvar;  /* number of active local variables */
73 |   upvaldesc upvalues[LUAI_MAXUPVALUES];  /* upvalues */
74 |   unsigned short actvar[LUAI_MAXVARS];  /* declared-variable stack */
75 | } FuncState;
76 | 
77 | 
78 | LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
79 |                                             const char *name);
80 | 
81 | 
82 | #endif
83 | 


--------------------------------------------------------------------------------
/lua53/llex.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: llex.h,v 1.79.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Lexical Analyzer
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef llex_h
 8 | #define llex_h
 9 | 
10 | #include "lobject.h"
11 | #include "lzio.h"
12 | 
13 | 
14 | #define FIRST_RESERVED	257
15 | 
16 | 
17 | #if !defined(LUA_ENV)
18 | #define LUA_ENV		"_ENV"
19 | #endif
20 | 
21 | 
22 | /*
23 | * WARNING: if you change the order of this enumeration,
24 | * grep "ORDER RESERVED"
25 | */
26 | enum RESERVED {
27 |   /* terminal symbols denoted by reserved words */
28 |   TK_AND = FIRST_RESERVED, TK_BREAK,
29 |   TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
30 |   TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
31 |   TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
32 |   /* other terminal symbols */
33 |   TK_IDIV, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE,
34 |   TK_SHL, TK_SHR,
35 |   TK_DBCOLON, TK_EOS,
36 |   TK_FLT, TK_INT, TK_NAME, TK_STRING
37 | };
38 | 
39 | /* number of reserved words */
40 | #define NUM_RESERVED	(cast(int, TK_WHILE-FIRST_RESERVED+1))
41 | 
42 | 
43 | typedef union {
44 |   lua_Number r;
45 |   lua_Integer i;
46 |   TString *ts;
47 | } SemInfo;  /* semantics information */
48 | 
49 | 
50 | typedef struct Token {
51 |   int token;
52 |   SemInfo seminfo;
53 | } Token;
54 | 
55 | 
56 | /* state of the lexer plus state of the parser when shared by all
57 |    functions */
58 | typedef struct LexState {
59 |   int current;  /* current character (charint) */
60 |   int linenumber;  /* input line counter */
61 |   int lastline;  /* line of last token 'consumed' */
62 |   Token t;  /* current token */
63 |   Token lookahead;  /* look ahead token */
64 |   struct FuncState *fs;  /* current function (parser) */
65 |   struct lua_State *L;
66 |   ZIO *z;  /* input stream */
67 |   Mbuffer *buff;  /* buffer for tokens */
68 |   Table *h;  /* to avoid collection/reuse strings */
69 |   struct Dyndata *dyd;  /* dynamic structures used by the parser */
70 |   TString *source;  /* current source name */
71 |   TString *envn;  /* environment variable name */
72 | } LexState;
73 | 
74 | 
75 | LUAI_FUNC void luaX_init (lua_State *L);
76 | LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
77 |                               TString *source, int firstchar);
78 | LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
79 | LUAI_FUNC void luaX_next (LexState *ls);
80 | LUAI_FUNC int luaX_lookahead (LexState *ls);
81 | LUAI_FUNC l_noret luaX_syntaxerror (LexState *ls, const char *s);
82 | LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
83 | 
84 | 
85 | #endif
86 | 


--------------------------------------------------------------------------------
/lua53/lmem.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lmem.h,v 1.43.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Interface to Memory Manager
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lmem_h
 8 | #define lmem_h
 9 | 
10 | 
11 | #include <stddef.h>
12 | 
13 | #include "llimits.h"
14 | #include "lua.h"
15 | 
16 | 
17 | /*
18 | ** This macro reallocs a vector 'b' from 'on' to 'n' elements, where
19 | ** each element has size 'e'. In case of arithmetic overflow of the
20 | ** product 'n'*'e', it raises an error (calling 'luaM_toobig'). Because
21 | ** 'e' is always constant, it avoids the runtime division MAX_SIZET/(e).
22 | **
23 | ** (The macro is somewhat complex to avoid warnings:  The 'sizeof'
24 | ** comparison avoids a runtime comparison when overflow cannot occur.
25 | ** The compiler should be able to optimize the real test by itself, but
26 | ** when it does it, it may give a warning about "comparison is always
27 | ** false due to limited range of data type"; the +1 tricks the compiler,
28 | ** avoiding this warning but also this optimization.)
29 | */
30 | #define luaM_reallocv(L,b,on,n,e) \
31 |   (((sizeof(n) >= sizeof(size_t) && cast(size_t, (n)) + 1 > MAX_SIZET/(e)) \
32 |       ? luaM_toobig(L) : cast_void(0)) , \
33 |    luaM_realloc_(L, (b), (on)*(e), (n)*(e)))
34 | 
35 | /*
36 | ** Arrays of chars do not need any test
37 | */
38 | #define luaM_reallocvchar(L,b,on,n)  \
39 |     cast(char *, luaM_realloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char)))
40 | 
41 | #define luaM_freemem(L, b, s)	luaM_realloc_(L, (b), (s), 0)
42 | #define luaM_free(L, b)		luaM_realloc_(L, (b), sizeof(*(b)), 0)
43 | #define luaM_freearray(L, b, n)   luaM_realloc_(L, (b), (n)*sizeof(*(b)), 0)
44 | 
45 | #define luaM_malloc(L,s)	luaM_realloc_(L, NULL, 0, (s))
46 | #define luaM_new(L,t)		cast(t *, luaM_malloc(L, sizeof(t)))
47 | #define luaM_newvector(L,n,t) \
48 | 		cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
49 | 
50 | #define luaM_newobject(L,tag,s)	luaM_realloc_(L, NULL, tag, (s))
51 | 
52 | #define luaM_growvector(L,v,nelems,size,t,limit,e) \
53 |           if ((nelems)+1 > (size)) \
54 |             ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
55 | 
56 | #define luaM_reallocvector(L, v,oldn,n,t) \
57 |    ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
58 | 
59 | LUAI_FUNC l_noret luaM_toobig (lua_State *L);
60 | 
61 | /* not to be called directly */
62 | LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
63 |                                                           size_t size);
64 | LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
65 |                                size_t size_elem, int limit,
66 |                                const char *what);
67 | 
68 | #endif
69 | 
70 | 


--------------------------------------------------------------------------------
/lua51/llimits.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: llimits.h,v 1.69.1.1 2007/12/27 13:02:25 roberto Exp $
  3 | ** Limits, basic types, and some other `installation-dependent' definitions
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #ifndef llimits_h
  8 | #define llimits_h
  9 | 
 10 | 
 11 | #include <limits.h>
 12 | #include <stddef.h>
 13 | 
 14 | 
 15 | #include "lua.h"
 16 | 
 17 | 
 18 | typedef LUAI_UINT32 lu_int32;
 19 | 
 20 | typedef LUAI_UMEM lu_mem;
 21 | 
 22 | typedef LUAI_MEM l_mem;
 23 | 
 24 | 
 25 | 
 26 | /* chars used as small naturals (so that `char' is reserved for characters) */
 27 | typedef unsigned char lu_byte;
 28 | 
 29 | 
 30 | #define MAX_SIZET	((size_t)(~(size_t)0)-2)
 31 | 
 32 | #define MAX_LUMEM	((lu_mem)(~(lu_mem)0)-2)
 33 | 
 34 | 
 35 | #define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
 36 | 
 37 | /*
 38 | ** conversion of pointer to integer
 39 | ** this is for hashing only; there is no problem if the integer
 40 | ** cannot hold the whole pointer value
 41 | */
 42 | #define IntPoint(p)  ((unsigned int)(lu_mem)(p))
 43 | 
 44 | 
 45 | 
 46 | /* type to ensure maximum alignment */
 47 | typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
 48 | 
 49 | 
 50 | /* result of a `usual argument conversion' over lua_Number */
 51 | typedef LUAI_UACNUMBER l_uacNumber;
 52 | 
 53 | 
 54 | /* internal assertions for in-house debugging */
 55 | #ifdef lua_assert
 56 | 
 57 | #define check_exp(c,e)		(lua_assert(c), (e))
 58 | #define api_check(l,e)		lua_assert(e)
 59 | 
 60 | #else
 61 | 
 62 | #define lua_assert(c)		((void)0)
 63 | #define check_exp(c,e)		(e)
 64 | #define api_check		luai_apicheck
 65 | 
 66 | #endif
 67 | 
 68 | 
 69 | #ifndef UNUSED
 70 | #define UNUSED(x)	((void)(x))	/* to avoid warnings */
 71 | #endif
 72 | 
 73 | 
 74 | #ifndef cast
 75 | #define cast(t, exp)	((t)(exp))
 76 | #endif
 77 | 
 78 | #define cast_byte(i)	cast(lu_byte, (i))
 79 | #define cast_num(i)	cast(lua_Number, (i))
 80 | #define cast_int(i)	cast(int, (i))
 81 | 
 82 | 
 83 | 
 84 | /*
 85 | ** type for virtual-machine instructions
 86 | ** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
 87 | */
 88 | typedef lu_int32 Instruction;
 89 | 
 90 | 
 91 | 
 92 | /* maximum stack for a Lua function */
 93 | #define MAXSTACK	250
 94 | 
 95 | 
 96 | 
 97 | /* minimum size for the string table (must be power of 2) */
 98 | #ifndef MINSTRTABSIZE
 99 | #define MINSTRTABSIZE	32
100 | #endif
101 | 
102 | 
103 | /* minimum size for string buffer */
104 | #ifndef LUA_MINBUFFER
105 | #define LUA_MINBUFFER	32
106 | #endif
107 | 
108 | 
109 | #ifndef lua_lock
110 | #define lua_lock(L)     ((void) 0) 
111 | #define lua_unlock(L)   ((void) 0)
112 | #endif
113 | 
114 | #ifndef luai_threadyield
115 | #define luai_threadyield(L)     {lua_unlock(L); lua_lock(L);}
116 | #endif
117 | 
118 | 
119 | /*
120 | ** macro to control inclusion of some hard tests on stack reallocation
121 | */ 
122 | #ifndef HARDSTACKTESTS
123 | #define condhardstacktests(x)	((void)0)
124 | #else
125 | #define condhardstacktests(x)	x
126 | #endif
127 | 
128 | #endif
129 | 


--------------------------------------------------------------------------------
/lua51/lcode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lcode.h,v 1.48.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Code generator for Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lcode_h
 8 | #define lcode_h
 9 | 
10 | #include "llex.h"
11 | #include "lobject.h"
12 | #include "lopcodes.h"
13 | #include "lparser.h"
14 | 
15 | 
16 | /*
17 | ** Marks the end of a patch list. It is an invalid value both as an absolute
18 | ** address, and as a list link (would link an element to itself).
19 | */
20 | #define NO_JUMP (-1)
21 | 
22 | 
23 | /*
24 | ** grep "ORDER OPR" if you change these enums
25 | */
26 | typedef enum BinOpr {
27 |   OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
28 |   OPR_CONCAT,
29 |   OPR_NE, OPR_EQ,
30 |   OPR_LT, OPR_LE, OPR_GT, OPR_GE,
31 |   OPR_AND, OPR_OR,
32 |   OPR_NOBINOPR
33 | } BinOpr;
34 | 
35 | 
36 | typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
37 | 
38 | 
39 | #define getcode(fs,e)	((fs)->f->code[(e)->u.s.info])
40 | 
41 | #define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
42 | 
43 | #define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
44 | 
45 | LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
46 | LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
47 | LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
48 | LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
49 | LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
50 | LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
51 | LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
52 | LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
53 | LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
54 | LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
55 | LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
56 | LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
57 | LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
58 | LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
59 | LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
60 | LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
61 | LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
62 | LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
63 | LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
64 | LUAI_FUNC int luaK_jump (FuncState *fs);
65 | LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
66 | LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
67 | LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
68 | LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
69 | LUAI_FUNC int luaK_getlabel (FuncState *fs);
70 | LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
71 | LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
72 | LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
73 | LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
74 | 
75 | 
76 | #endif
77 | 


--------------------------------------------------------------------------------
/lua52/lmem.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lmem.c,v 1.84.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Interface to Memory Manager
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <stddef.h>
  9 | 
 10 | #define lmem_c
 11 | #define LUA_CORE
 12 | 
 13 | #include "lua.h"
 14 | 
 15 | #include "ldebug.h"
 16 | #include "ldo.h"
 17 | #include "lgc.h"
 18 | #include "lmem.h"
 19 | #include "lobject.h"
 20 | #include "lstate.h"
 21 | 
 22 | 
 23 | 
 24 | /*
 25 | ** About the realloc function:
 26 | ** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
 27 | ** (`osize' is the old size, `nsize' is the new size)
 28 | **
 29 | ** * frealloc(ud, NULL, x, s) creates a new block of size `s' (no
 30 | ** matter 'x').
 31 | **
 32 | ** * frealloc(ud, p, x, 0) frees the block `p'
 33 | ** (in this specific case, frealloc must return NULL);
 34 | ** particularly, frealloc(ud, NULL, 0, 0) does nothing
 35 | ** (which is equivalent to free(NULL) in ANSI C)
 36 | **
 37 | ** frealloc returns NULL if it cannot create or reallocate the area
 38 | ** (any reallocation to an equal or smaller size cannot fail!)
 39 | */
 40 | 
 41 | 
 42 | 
 43 | #define MINSIZEARRAY	4
 44 | 
 45 | 
 46 | void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
 47 |                      int limit, const char *what) {
 48 |   void *newblock;
 49 |   int newsize;
 50 |   if (*size >= limit/2) {  /* cannot double it? */
 51 |     if (*size >= limit)  /* cannot grow even a little? */
 52 |       luaG_runerror(L, "too many %s (limit is %d)", what, limit);
 53 |     newsize = limit;  /* still have at least one free place */
 54 |   }
 55 |   else {
 56 |     newsize = (*size)*2;
 57 |     if (newsize < MINSIZEARRAY)
 58 |       newsize = MINSIZEARRAY;  /* minimum size */
 59 |   }
 60 |   newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
 61 |   *size = newsize;  /* update only when everything else is OK */
 62 |   return newblock;
 63 | }
 64 | 
 65 | 
 66 | l_noret luaM_toobig (lua_State *L) {
 67 |   luaG_runerror(L, "memory allocation error: block too big");
 68 | }
 69 | 
 70 | 
 71 | 
 72 | /*
 73 | ** generic allocation routine.
 74 | */
 75 | void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
 76 |   void *newblock;
 77 |   global_State *g = G(L);
 78 |   size_t realosize = (block) ? osize : 0;
 79 |   lua_assert((realosize == 0) == (block == NULL));
 80 | #if defined(HARDMEMTESTS)
 81 |   if (nsize > realosize && g->gcrunning)
 82 |     luaC_fullgc(L, 1);  /* force a GC whenever possible */
 83 | #endif
 84 |   newblock = (*g->frealloc)(g->ud, block, osize, nsize);
 85 |   if (newblock == NULL && nsize > 0) {
 86 |     api_check(L, nsize > realosize,
 87 |                  "realloc cannot fail when shrinking a block");
 88 |     if (g->gcrunning) {
 89 |       luaC_fullgc(L, 1);  /* try to free some memory... */
 90 |       newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
 91 |     }
 92 |     if (newblock == NULL)
 93 |       luaD_throw(L, LUA_ERRMEM);
 94 |   }
 95 |   lua_assert((nsize == 0) == (newblock == NULL));
 96 |   g->GCdebt = (g->GCdebt + nsize) - realosize;
 97 |   return newblock;
 98 | }
 99 | 
100 | 


--------------------------------------------------------------------------------
/lua53/lmem.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lmem.c,v 1.91.1.1 2017/04/19 17:20:42 roberto Exp $
  3 | ** Interface to Memory Manager
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #define lmem_c
  8 | #define LUA_CORE
  9 | 
 10 | #include "lprefix.h"
 11 | 
 12 | 
 13 | #include <stddef.h>
 14 | 
 15 | #include "lua.h"
 16 | 
 17 | #include "ldebug.h"
 18 | #include "ldo.h"
 19 | #include "lgc.h"
 20 | #include "lmem.h"
 21 | #include "lobject.h"
 22 | #include "lstate.h"
 23 | 
 24 | 
 25 | 
 26 | /*
 27 | ** About the realloc function:
 28 | ** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
 29 | ** ('osize' is the old size, 'nsize' is the new size)
 30 | **
 31 | ** * frealloc(ud, NULL, x, s) creates a new block of size 's' (no
 32 | ** matter 'x').
 33 | **
 34 | ** * frealloc(ud, p, x, 0) frees the block 'p'
 35 | ** (in this specific case, frealloc must return NULL);
 36 | ** particularly, frealloc(ud, NULL, 0, 0) does nothing
 37 | ** (which is equivalent to free(NULL) in ISO C)
 38 | **
 39 | ** frealloc returns NULL if it cannot create or reallocate the area
 40 | ** (any reallocation to an equal or smaller size cannot fail!)
 41 | */
 42 | 
 43 | 
 44 | 
 45 | #define MINSIZEARRAY	4
 46 | 
 47 | 
 48 | void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
 49 |                      int limit, const char *what) {
 50 |   void *newblock;
 51 |   int newsize;
 52 |   if (*size >= limit/2) {  /* cannot double it? */
 53 |     if (*size >= limit)  /* cannot grow even a little? */
 54 |       luaG_runerror(L, "too many %s (limit is %d)", what, limit);
 55 |     newsize = limit;  /* still have at least one free place */
 56 |   }
 57 |   else {
 58 |     newsize = (*size)*2;
 59 |     if (newsize < MINSIZEARRAY)
 60 |       newsize = MINSIZEARRAY;  /* minimum size */
 61 |   }
 62 |   newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
 63 |   *size = newsize;  /* update only when everything else is OK */
 64 |   return newblock;
 65 | }
 66 | 
 67 | 
 68 | l_noret luaM_toobig (lua_State *L) {
 69 |   luaG_runerror(L, "memory allocation error: block too big");
 70 | }
 71 | 
 72 | 
 73 | 
 74 | /*
 75 | ** generic allocation routine.
 76 | */
 77 | void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
 78 |   void *newblock;
 79 |   global_State *g = G(L);
 80 |   size_t realosize = (block) ? osize : 0;
 81 |   lua_assert((realosize == 0) == (block == NULL));
 82 | #if defined(HARDMEMTESTS)
 83 |   if (nsize > realosize && g->gcrunning)
 84 |     luaC_fullgc(L, 1);  /* force a GC whenever possible */
 85 | #endif
 86 |   newblock = (*g->frealloc)(g->ud, block, osize, nsize);
 87 |   if (newblock == NULL && nsize > 0) {
 88 |     lua_assert(nsize > realosize);  /* cannot fail when shrinking a block */
 89 |     if (g->version) {  /* is state fully built? */
 90 |       luaC_fullgc(L, 1);  /* try to free some memory... */
 91 |       newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
 92 |     }
 93 |     if (newblock == NULL)
 94 |       luaD_throw(L, LUA_ERRMEM);
 95 |   }
 96 |   lua_assert((nsize == 0) == (newblock == NULL));
 97 |   g->GCdebt = (g->GCdebt + nsize) - realosize;
 98 |   return newblock;
 99 | }
100 | 
101 | 


--------------------------------------------------------------------------------
/lua51/lopcodes.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lopcodes.c,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $
  3 | ** See Copyright Notice in lua.h
  4 | */
  5 | 
  6 | 
  7 | #define lopcodes_c
  8 | #define LUA_CORE
  9 | 
 10 | 
 11 | #include "lopcodes.h"
 12 | 
 13 | 
 14 | /* ORDER OP */
 15 | 
 16 | const char *const luaP_opnames[NUM_OPCODES+1] = {
 17 |   "MOVE",
 18 |   "LOADK",
 19 |   "LOADBOOL",
 20 |   "LOADNIL",
 21 |   "GETUPVAL",
 22 |   "GETGLOBAL",
 23 |   "GETTABLE",
 24 |   "SETGLOBAL",
 25 |   "SETUPVAL",
 26 |   "SETTABLE",
 27 |   "NEWTABLE",
 28 |   "SELF",
 29 |   "ADD",
 30 |   "SUB",
 31 |   "MUL",
 32 |   "DIV",
 33 |   "MOD",
 34 |   "POW",
 35 |   "UNM",
 36 |   "NOT",
 37 |   "LEN",
 38 |   "CONCAT",
 39 |   "JMP",
 40 |   "EQ",
 41 |   "LT",
 42 |   "LE",
 43 |   "TEST",
 44 |   "TESTSET",
 45 |   "CALL",
 46 |   "TAILCALL",
 47 |   "RETURN",
 48 |   "FORLOOP",
 49 |   "FORPREP",
 50 |   "TFORLOOP",
 51 |   "SETLIST",
 52 |   "CLOSE",
 53 |   "CLOSURE",
 54 |   "VARARG",
 55 |   NULL
 56 | };
 57 | 
 58 | 
 59 | #define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
 60 | 
 61 | const lu_byte luaP_opmodes[NUM_OPCODES] = {
 62 | /*       T  A    B       C     mode		   opcode	*/
 63 |   opmode(0, 1, OpArgR, OpArgN, iABC) 		/* OP_MOVE */
 64 |  ,opmode(0, 1, OpArgK, OpArgN, iABx)		/* OP_LOADK */
 65 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_LOADBOOL */
 66 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LOADNIL */
 67 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_GETUPVAL */
 68 |  ,opmode(0, 1, OpArgK, OpArgN, iABx)		/* OP_GETGLOBAL */
 69 |  ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_GETTABLE */
 70 |  ,opmode(0, 0, OpArgK, OpArgN, iABx)		/* OP_SETGLOBAL */
 71 |  ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_SETUPVAL */
 72 |  ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABLE */
 73 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_NEWTABLE */
 74 |  ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_SELF */
 75 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_ADD */
 76 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SUB */
 77 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MUL */
 78 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
 79 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MOD */
 80 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_POW */
 81 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_UNM */
 82 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_NOT */
 83 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LEN */
 84 |  ,opmode(0, 1, OpArgR, OpArgR, iABC)		/* OP_CONCAT */
 85 |  ,opmode(0, 0, OpArgR, OpArgN, iAsBx)		/* OP_JMP */
 86 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_EQ */
 87 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LT */
 88 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LE */
 89 |  ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TEST */
 90 |  ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TESTSET */
 91 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_CALL */
 92 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_TAILCALL */
 93 |  ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_RETURN */
 94 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORLOOP */
 95 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORPREP */
 96 |  ,opmode(1, 0, OpArgN, OpArgU, iABC)		/* OP_TFORLOOP */
 97 |  ,opmode(0, 0, OpArgU, OpArgU, iABC)		/* OP_SETLIST */
 98 |  ,opmode(0, 0, OpArgN, OpArgN, iABC)		/* OP_CLOSE */
 99 |  ,opmode(0, 1, OpArgU, OpArgN, iABx)		/* OP_CLOSURE */
100 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_VARARG */
101 | };
102 | 
103 | 


--------------------------------------------------------------------------------
/lua52/lcode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lcode.h,v 1.58.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Code generator for Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lcode_h
 8 | #define lcode_h
 9 | 
10 | #include "llex.h"
11 | #include "lobject.h"
12 | #include "lopcodes.h"
13 | #include "lparser.h"
14 | 
15 | 
16 | /*
17 | ** Marks the end of a patch list. It is an invalid value both as an absolute
18 | ** address, and as a list link (would link an element to itself).
19 | */
20 | #define NO_JUMP (-1)
21 | 
22 | 
23 | /*
24 | ** grep "ORDER OPR" if you change these enums  (ORDER OP)
25 | */
26 | typedef enum BinOpr {
27 |   OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
28 |   OPR_CONCAT,
29 |   OPR_EQ, OPR_LT, OPR_LE,
30 |   OPR_NE, OPR_GT, OPR_GE,
31 |   OPR_AND, OPR_OR,
32 |   OPR_NOBINOPR
33 | } BinOpr;
34 | 
35 | 
36 | typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
37 | 
38 | 
39 | #define getcode(fs,e)	((fs)->f->code[(e)->u.info])
40 | 
41 | #define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
42 | 
43 | #define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
44 | 
45 | #define luaK_jumpto(fs,t)	luaK_patchlist(fs, luaK_jump(fs), t)
46 | 
47 | LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
48 | LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
49 | LUAI_FUNC int luaK_codek (FuncState *fs, int reg, int k);
50 | LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
51 | LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
52 | LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
53 | LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
54 | LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
55 | LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
56 | LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
57 | LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
58 | LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e);
59 | LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
60 | LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
61 | LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
62 | LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
63 | LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
64 | LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
65 | LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e);
66 | LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
67 | LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
68 | LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
69 | LUAI_FUNC int luaK_jump (FuncState *fs);
70 | LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
71 | LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
72 | LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
73 | LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level);
74 | LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
75 | LUAI_FUNC int luaK_getlabel (FuncState *fs);
76 | LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);
77 | LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
78 | LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1,
79 |                             expdesc *v2, int line);
80 | LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
81 | 
82 | 
83 | #endif
84 | 


--------------------------------------------------------------------------------
/lua53/lcode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lcode.h,v 1.64.1.1 2017/04/19 17:20:42 roberto Exp $
 3 | ** Code generator for Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lcode_h
 8 | #define lcode_h
 9 | 
10 | #include "llex.h"
11 | #include "lobject.h"
12 | #include "lopcodes.h"
13 | #include "lparser.h"
14 | 
15 | 
16 | /*
17 | ** Marks the end of a patch list. It is an invalid value both as an absolute
18 | ** address, and as a list link (would link an element to itself).
19 | */
20 | #define NO_JUMP (-1)
21 | 
22 | 
23 | /*
24 | ** grep "ORDER OPR" if you change these enums  (ORDER OP)
25 | */
26 | typedef enum BinOpr {
27 |   OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW,
28 |   OPR_DIV,
29 |   OPR_IDIV,
30 |   OPR_BAND, OPR_BOR, OPR_BXOR,
31 |   OPR_SHL, OPR_SHR,
32 |   OPR_CONCAT,
33 |   OPR_EQ, OPR_LT, OPR_LE,
34 |   OPR_NE, OPR_GT, OPR_GE,
35 |   OPR_AND, OPR_OR,
36 |   OPR_NOBINOPR
37 | } BinOpr;
38 | 
39 | 
40 | typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
41 | 
42 | 
43 | /* get (pointer to) instruction of given 'expdesc' */
44 | #define getinstruction(fs,e)	((fs)->f->code[(e)->u.info])
45 | 
46 | #define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
47 | 
48 | #define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
49 | 
50 | #define luaK_jumpto(fs,t)	luaK_patchlist(fs, luaK_jump(fs), t)
51 | 
52 | LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
53 | LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
54 | LUAI_FUNC int luaK_codek (FuncState *fs, int reg, int k);
55 | LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
56 | LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
57 | LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
58 | LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
59 | LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
60 | LUAI_FUNC int luaK_intK (FuncState *fs, lua_Integer n);
61 | LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
62 | LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
63 | LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e);
64 | LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
65 | LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
66 | LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
67 | LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
68 | LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
69 | LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
70 | LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e);
71 | LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
72 | LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
73 | LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
74 | LUAI_FUNC int luaK_jump (FuncState *fs);
75 | LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
76 | LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
77 | LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
78 | LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level);
79 | LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
80 | LUAI_FUNC int luaK_getlabel (FuncState *fs);
81 | LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);
82 | LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
83 | LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1,
84 |                             expdesc *v2, int line);
85 | LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
86 | 
87 | 
88 | #endif
89 | 


--------------------------------------------------------------------------------
/lua52/lopcodes.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lopcodes.c,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Opcodes for Lua virtual machine
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #define lopcodes_c
  9 | #define LUA_CORE
 10 | 
 11 | 
 12 | #include "lopcodes.h"
 13 | 
 14 | 
 15 | /* ORDER OP */
 16 | 
 17 | LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
 18 |   "MOVE",
 19 |   "LOADK",
 20 |   "LOADKX",
 21 |   "LOADBOOL",
 22 |   "LOADNIL",
 23 |   "GETUPVAL",
 24 |   "GETTABUP",
 25 |   "GETTABLE",
 26 |   "SETTABUP",
 27 |   "SETUPVAL",
 28 |   "SETTABLE",
 29 |   "NEWTABLE",
 30 |   "SELF",
 31 |   "ADD",
 32 |   "SUB",
 33 |   "MUL",
 34 |   "DIV",
 35 |   "MOD",
 36 |   "POW",
 37 |   "UNM",
 38 |   "NOT",
 39 |   "LEN",
 40 |   "CONCAT",
 41 |   "JMP",
 42 |   "EQ",
 43 |   "LT",
 44 |   "LE",
 45 |   "TEST",
 46 |   "TESTSET",
 47 |   "CALL",
 48 |   "TAILCALL",
 49 |   "RETURN",
 50 |   "FORLOOP",
 51 |   "FORPREP",
 52 |   "TFORCALL",
 53 |   "TFORLOOP",
 54 |   "SETLIST",
 55 |   "CLOSURE",
 56 |   "VARARG",
 57 |   "EXTRAARG",
 58 |   NULL
 59 | };
 60 | 
 61 | 
 62 | #define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
 63 | 
 64 | LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
 65 | /*       T  A    B       C     mode		   opcode	*/
 66 |   opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_MOVE */
 67 |  ,opmode(0, 1, OpArgK, OpArgN, iABx)		/* OP_LOADK */
 68 |  ,opmode(0, 1, OpArgN, OpArgN, iABx)		/* OP_LOADKX */
 69 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_LOADBOOL */
 70 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_LOADNIL */
 71 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_GETUPVAL */
 72 |  ,opmode(0, 1, OpArgU, OpArgK, iABC)		/* OP_GETTABUP */
 73 |  ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_GETTABLE */
 74 |  ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABUP */
 75 |  ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_SETUPVAL */
 76 |  ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABLE */
 77 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_NEWTABLE */
 78 |  ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_SELF */
 79 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_ADD */
 80 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SUB */
 81 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MUL */
 82 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
 83 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MOD */
 84 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_POW */
 85 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_UNM */
 86 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_NOT */
 87 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LEN */
 88 |  ,opmode(0, 1, OpArgR, OpArgR, iABC)		/* OP_CONCAT */
 89 |  ,opmode(0, 0, OpArgR, OpArgN, iAsBx)		/* OP_JMP */
 90 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_EQ */
 91 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LT */
 92 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LE */
 93 |  ,opmode(1, 0, OpArgN, OpArgU, iABC)		/* OP_TEST */
 94 |  ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TESTSET */
 95 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_CALL */
 96 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_TAILCALL */
 97 |  ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_RETURN */
 98 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORLOOP */
 99 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORPREP */
100 |  ,opmode(0, 0, OpArgN, OpArgU, iABC)		/* OP_TFORCALL */
101 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_TFORLOOP */
102 |  ,opmode(0, 0, OpArgU, OpArgU, iABC)		/* OP_SETLIST */
103 |  ,opmode(0, 1, OpArgU, OpArgN, iABx)		/* OP_CLOSURE */
104 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_VARARG */
105 |  ,opmode(0, 0, OpArgU, OpArgU, iAx)		/* OP_EXTRAARG */
106 | };
107 | 
108 | 


--------------------------------------------------------------------------------
/lua51/lstring.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lstring.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
  3 | ** String table (keeps all strings handled by Lua)
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <string.h>
  9 | 
 10 | #define lstring_c
 11 | #define LUA_CORE
 12 | 
 13 | #include "lua.h"
 14 | 
 15 | #include "lmem.h"
 16 | #include "lobject.h"
 17 | #include "lstate.h"
 18 | #include "lstring.h"
 19 | 
 20 | 
 21 | 
 22 | void luaS_resize (lua_State *L, int newsize) {
 23 |   GCObject **newhash;
 24 |   stringtable *tb;
 25 |   int i;
 26 |   if (G(L)->gcstate == GCSsweepstring)
 27 |     return;  /* cannot resize during GC traverse */
 28 |   newhash = luaM_newvector(L, newsize, GCObject *);
 29 |   tb = &G(L)->strt;
 30 |   for (i=0; i<newsize; i++) newhash[i] = NULL;
 31 |   /* rehash */
 32 |   for (i=0; i<tb->size; i++) {
 33 |     GCObject *p = tb->hash[i];
 34 |     while (p) {  /* for each node in the list */
 35 |       GCObject *next = p->gch.next;  /* save next */
 36 |       unsigned int h = gco2ts(p)->hash;
 37 |       int h1 = lmod(h, newsize);  /* new position */
 38 |       lua_assert(cast_int(h%newsize) == lmod(h, newsize));
 39 |       p->gch.next = newhash[h1];  /* chain it */
 40 |       newhash[h1] = p;
 41 |       p = next;
 42 |     }
 43 |   }
 44 |   luaM_freearray(L, tb->hash, tb->size, TString *);
 45 |   tb->size = newsize;
 46 |   tb->hash = newhash;
 47 | }
 48 | 
 49 | 
 50 | static TString *newlstr (lua_State *L, const char *str, size_t l,
 51 |                                        unsigned int h) {
 52 |   TString *ts;
 53 |   stringtable *tb;
 54 |   if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
 55 |     luaM_toobig(L);
 56 |   ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
 57 |   ts->tsv.len = l;
 58 |   ts->tsv.hash = h;
 59 |   ts->tsv.marked = luaC_white(G(L));
 60 |   ts->tsv.tt = LUA_TSTRING;
 61 |   ts->tsv.reserved = 0;
 62 |   memcpy(ts+1, str, l*sizeof(char));
 63 |   ((char *)(ts+1))[l] = '\0';  /* ending 0 */
 64 |   tb = &G(L)->strt;
 65 |   h = lmod(h, tb->size);
 66 |   ts->tsv.next = tb->hash[h];  /* chain new entry */
 67 |   tb->hash[h] = obj2gco(ts);
 68 |   tb->nuse++;
 69 |   if (tb->nuse > cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
 70 |     luaS_resize(L, tb->size*2);  /* too crowded */
 71 |   return ts;
 72 | }
 73 | 
 74 | 
 75 | TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
 76 |   GCObject *o;
 77 |   unsigned int h = cast(unsigned int, l);  /* seed */
 78 |   size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
 79 |   size_t l1;
 80 |   for (l1=l; l1>=step; l1-=step)  /* compute hash */
 81 |     h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
 82 |   for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
 83 |        o != NULL;
 84 |        o = o->gch.next) {
 85 |     TString *ts = rawgco2ts(o);
 86 |     if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) {
 87 |       /* string may be dead */
 88 |       if (isdead(G(L), o)) changewhite(o);
 89 |       return ts;
 90 |     }
 91 |   }
 92 |   return newlstr(L, str, l, h);  /* not found */
 93 | }
 94 | 
 95 | 
 96 | Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
 97 |   Udata *u;
 98 |   if (s > MAX_SIZET - sizeof(Udata))
 99 |     luaM_toobig(L);
100 |   u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
101 |   u->uv.marked = luaC_white(G(L));  /* is not finalized */
102 |   u->uv.tt = LUA_TUSERDATA;
103 |   u->uv.len = s;
104 |   u->uv.metatable = NULL;
105 |   u->uv.env = e;
106 |   /* chain it on udata list (after main thread) */
107 |   u->uv.next = G(L)->mainthread->next;
108 |   G(L)->mainthread->next = obj2gco(u);
109 |   return u;
110 | }
111 | 
112 | 


--------------------------------------------------------------------------------
/lua51/lgc.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lgc.h,v 2.15.1.1 2007/12/27 13:02:25 roberto Exp $
  3 | ** Garbage Collector
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #ifndef lgc_h
  8 | #define lgc_h
  9 | 
 10 | 
 11 | #include "lobject.h"
 12 | 
 13 | 
 14 | /*
 15 | ** Possible states of the Garbage Collector
 16 | */
 17 | #define GCSpause	0
 18 | #define GCSpropagate	1
 19 | #define GCSsweepstring	2
 20 | #define GCSsweep	3
 21 | #define GCSfinalize	4
 22 | 
 23 | 
 24 | /*
 25 | ** some userful bit tricks
 26 | */
 27 | #define resetbits(x,m)	((x) &= cast(lu_byte, ~(m)))
 28 | #define setbits(x,m)	((x) |= (m))
 29 | #define testbits(x,m)	((x) & (m))
 30 | #define bitmask(b)	(1<<(b))
 31 | #define bit2mask(b1,b2)	(bitmask(b1) | bitmask(b2))
 32 | #define l_setbit(x,b)	setbits(x, bitmask(b))
 33 | #define resetbit(x,b)	resetbits(x, bitmask(b))
 34 | #define testbit(x,b)	testbits(x, bitmask(b))
 35 | #define set2bits(x,b1,b2)	setbits(x, (bit2mask(b1, b2)))
 36 | #define reset2bits(x,b1,b2)	resetbits(x, (bit2mask(b1, b2)))
 37 | #define test2bits(x,b1,b2)	testbits(x, (bit2mask(b1, b2)))
 38 | 
 39 | 
 40 | 
 41 | /*
 42 | ** Layout for bit use in `marked' field:
 43 | ** bit 0 - object is white (type 0)
 44 | ** bit 1 - object is white (type 1)
 45 | ** bit 2 - object is black
 46 | ** bit 3 - for userdata: has been finalized
 47 | ** bit 3 - for tables: has weak keys
 48 | ** bit 4 - for tables: has weak values
 49 | ** bit 5 - object is fixed (should not be collected)
 50 | ** bit 6 - object is "super" fixed (only the main thread)
 51 | */
 52 | 
 53 | 
 54 | #define WHITE0BIT	0
 55 | #define WHITE1BIT	1
 56 | #define BLACKBIT	2
 57 | #define FINALIZEDBIT	3
 58 | #define KEYWEAKBIT	3
 59 | #define VALUEWEAKBIT	4
 60 | #define FIXEDBIT	5
 61 | #define SFIXEDBIT	6
 62 | #define WHITEBITS	bit2mask(WHITE0BIT, WHITE1BIT)
 63 | 
 64 | 
 65 | #define iswhite(x)      test2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
 66 | #define isblack(x)      testbit((x)->gch.marked, BLACKBIT)
 67 | #define isgray(x)	(!isblack(x) && !iswhite(x))
 68 | 
 69 | #define otherwhite(g)	(g->currentwhite ^ WHITEBITS)
 70 | #define isdead(g,v)	((v)->gch.marked & otherwhite(g) & WHITEBITS)
 71 | 
 72 | #define changewhite(x)	((x)->gch.marked ^= WHITEBITS)
 73 | #define gray2black(x)	l_setbit((x)->gch.marked, BLACKBIT)
 74 | 
 75 | #define valiswhite(x)	(iscollectable(x) && iswhite(gcvalue(x)))
 76 | 
 77 | #define luaC_white(g)	cast(lu_byte, (g)->currentwhite & WHITEBITS)
 78 | 
 79 | 
 80 | #define luaC_checkGC(L) { \
 81 |   condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); \
 82 |   if (G(L)->totalbytes >= G(L)->GCthreshold) \
 83 | 	luaC_step(L); }
 84 | 
 85 | 
 86 | #define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
 87 | 	luaC_barrierf(L,obj2gco(p),gcvalue(v)); }
 88 | 
 89 | #define luaC_barriert(L,t,v) { if (valiswhite(v) && isblack(obj2gco(t)))  \
 90 | 	luaC_barrierback(L,t); }
 91 | 
 92 | #define luaC_objbarrier(L,p,o)  \
 93 | 	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
 94 | 		luaC_barrierf(L,obj2gco(p),obj2gco(o)); }
 95 | 
 96 | #define luaC_objbarriert(L,t,o)  \
 97 |    { if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) luaC_barrierback(L,t); }
 98 | 
 99 | LUAI_FUNC size_t luaC_separateudata (lua_State *L, int all);
100 | LUAI_FUNC void luaC_callGCTM (lua_State *L);
101 | LUAI_FUNC void luaC_freeall (lua_State *L);
102 | LUAI_FUNC void luaC_step (lua_State *L);
103 | LUAI_FUNC void luaC_fullgc (lua_State *L);
104 | LUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt);
105 | LUAI_FUNC void luaC_linkupval (lua_State *L, UpVal *uv);
106 | LUAI_FUNC void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v);
107 | LUAI_FUNC void luaC_barrierback (lua_State *L, Table *t);
108 | 
109 | 
110 | #endif
111 | 


--------------------------------------------------------------------------------
/lua52/lparser.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lparser.h,v 1.70.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Lua Parser
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #ifndef lparser_h
  8 | #define lparser_h
  9 | 
 10 | #include "llimits.h"
 11 | #include "lobject.h"
 12 | #include "lzio.h"
 13 | 
 14 | 
 15 | /*
 16 | ** Expression descriptor
 17 | */
 18 | 
 19 | typedef enum {
 20 |   VVOID,	/* no value */
 21 |   VNIL,
 22 |   VTRUE,
 23 |   VFALSE,
 24 |   VK,		/* info = index of constant in `k' */
 25 |   VKNUM,	/* nval = numerical value */
 26 |   VNONRELOC,	/* info = result register */
 27 |   VLOCAL,	/* info = local register */
 28 |   VUPVAL,       /* info = index of upvalue in 'upvalues' */
 29 |   VINDEXED,	/* t = table register/upvalue; idx = index R/K */
 30 |   VJMP,		/* info = instruction pc */
 31 |   VRELOCABLE,	/* info = instruction pc */
 32 |   VCALL,	/* info = instruction pc */
 33 |   VVARARG	/* info = instruction pc */
 34 | } expkind;
 35 | 
 36 | 
 37 | #define vkisvar(k)	(VLOCAL <= (k) && (k) <= VINDEXED)
 38 | #define vkisinreg(k)	((k) == VNONRELOC || (k) == VLOCAL)
 39 | 
 40 | typedef struct expdesc {
 41 |   expkind k;
 42 |   union {
 43 |     struct {  /* for indexed variables (VINDEXED) */
 44 |       short idx;  /* index (R/K) */
 45 |       lu_byte t;  /* table (register or upvalue) */
 46 |       lu_byte vt;  /* whether 't' is register (VLOCAL) or upvalue (VUPVAL) */
 47 |     } ind;
 48 |     int info;  /* for generic use */
 49 |     lua_Number nval;  /* for VKNUM */
 50 |   } u;
 51 |   int t;  /* patch list of `exit when true' */
 52 |   int f;  /* patch list of `exit when false' */
 53 | } expdesc;
 54 | 
 55 | 
 56 | /* description of active local variable */
 57 | typedef struct Vardesc {
 58 |   short idx;  /* variable index in stack */
 59 | } Vardesc;
 60 | 
 61 | 
 62 | /* description of pending goto statements and label statements */
 63 | typedef struct Labeldesc {
 64 |   TString *name;  /* label identifier */
 65 |   int pc;  /* position in code */
 66 |   int line;  /* line where it appeared */
 67 |   lu_byte nactvar;  /* local level where it appears in current block */
 68 | } Labeldesc;
 69 | 
 70 | 
 71 | /* list of labels or gotos */
 72 | typedef struct Labellist {
 73 |   Labeldesc *arr;  /* array */
 74 |   int n;  /* number of entries in use */
 75 |   int size;  /* array size */
 76 | } Labellist;
 77 | 
 78 | 
 79 | /* dynamic structures used by the parser */
 80 | typedef struct Dyndata {
 81 |   struct {  /* list of active local variables */
 82 |     Vardesc *arr;
 83 |     int n;
 84 |     int size;
 85 |   } actvar;
 86 |   Labellist gt;  /* list of pending gotos */
 87 |   Labellist label;   /* list of active labels */
 88 | } Dyndata;
 89 | 
 90 | 
 91 | /* control of blocks */
 92 | struct BlockCnt;  /* defined in lparser.c */
 93 | 
 94 | 
 95 | /* state needed to generate code for a given function */
 96 | typedef struct FuncState {
 97 |   Proto *f;  /* current function header */
 98 |   Table *h;  /* table to find (and reuse) elements in `k' */
 99 |   struct FuncState *prev;  /* enclosing function */
100 |   struct LexState *ls;  /* lexical state */
101 |   struct BlockCnt *bl;  /* chain of current blocks */
102 |   int pc;  /* next position to code (equivalent to `ncode') */
103 |   int lasttarget;   /* 'label' of last 'jump label' */
104 |   int jpc;  /* list of pending jumps to `pc' */
105 |   int nk;  /* number of elements in `k' */
106 |   int np;  /* number of elements in `p' */
107 |   int firstlocal;  /* index of first local var (in Dyndata array) */
108 |   short nlocvars;  /* number of elements in 'f->locvars' */
109 |   lu_byte nactvar;  /* number of active local variables */
110 |   lu_byte nups;  /* number of upvalues */
111 |   lu_byte freereg;  /* first free register */
112 | } FuncState;
113 | 
114 | 
115 | LUAI_FUNC Closure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
116 |                                 Dyndata *dyd, const char *name, int firstchar);
117 | 
118 | 
119 | #endif
120 | 


--------------------------------------------------------------------------------
/lua51/ldump.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: ldump.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
  3 | ** save precompiled Lua chunks
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #include <stddef.h>
  8 | 
  9 | #define ldump_c
 10 | #define LUA_CORE
 11 | 
 12 | #include "lua.h"
 13 | 
 14 | #include "lobject.h"
 15 | #include "lstate.h"
 16 | #include "lundump.h"
 17 | 
 18 | typedef struct {
 19 |  lua_State* L;
 20 |  lua_Writer writer;
 21 |  void* data;
 22 |  int strip;
 23 |  int status;
 24 | } DumpState;
 25 | 
 26 | #define DumpMem(b,n,size,D)	DumpBlock(b,(n)*(size),D)
 27 | #define DumpVar(x,D)	 	DumpMem(&x,1,sizeof(x),D)
 28 | 
 29 | static void DumpBlock(const void* b, size_t size, DumpState* D)
 30 | {
 31 |  if (D->status==0)
 32 |  {
 33 |   lua_unlock(D->L);
 34 |   D->status=(*D->writer)(D->L,b,size,D->data);
 35 |   lua_lock(D->L);
 36 |  }
 37 | }
 38 | 
 39 | static void DumpChar(int y, DumpState* D)
 40 | {
 41 |  char x=(char)y;
 42 |  DumpVar(x,D);
 43 | }
 44 | 
 45 | static void DumpInt(int x, DumpState* D)
 46 | {
 47 |  DumpVar(x,D);
 48 | }
 49 | 
 50 | static void DumpNumber(lua_Number x, DumpState* D)
 51 | {
 52 |  DumpVar(x,D);
 53 | }
 54 | 
 55 | static void DumpVector(const void* b, int n, size_t size, DumpState* D)
 56 | {
 57 |  DumpInt(n,D);
 58 |  DumpMem(b,n,size,D);
 59 | }
 60 | 
 61 | static void DumpString(const TString* s, DumpState* D)
 62 | {
 63 |  if (s==NULL || getstr(s)==NULL)
 64 |  {
 65 |   size_t size=0;
 66 |   DumpVar(size,D);
 67 |  }
 68 |  else
 69 |  {
 70 |   size_t size=s->tsv.len+1;		/* include trailing '\0' */
 71 |   DumpVar(size,D);
 72 |   DumpBlock(getstr(s),size,D);
 73 |  }
 74 | }
 75 | 
 76 | #define DumpCode(f,D)	 DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
 77 | 
 78 | static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
 79 | 
 80 | static void DumpConstants(const Proto* f, DumpState* D)
 81 | {
 82 |  int i,n=f->sizek;
 83 |  DumpInt(n,D);
 84 |  for (i=0; i<n; i++)
 85 |  {
 86 |   const TValue* o=&f->k[i];
 87 |   DumpChar(ttype(o),D);
 88 |   switch (ttype(o))
 89 |   {
 90 |    case LUA_TNIL:
 91 | 	break;
 92 |    case LUA_TBOOLEAN:
 93 | 	DumpChar(bvalue(o),D);
 94 | 	break;
 95 |    case LUA_TNUMBER:
 96 | 	DumpNumber(nvalue(o),D);
 97 | 	break;
 98 |    case LUA_TSTRING:
 99 | 	DumpString(rawtsvalue(o),D);
100 | 	break;
101 |    default:
102 | 	lua_assert(0);			/* cannot happen */
103 | 	break;
104 |   }
105 |  }
106 |  n=f->sizep;
107 |  DumpInt(n,D);
108 |  for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);
109 | }
110 | 
111 | static void DumpDebug(const Proto* f, DumpState* D)
112 | {
113 |  int i,n;
114 |  n= (D->strip) ? 0 : f->sizelineinfo;
115 |  DumpVector(f->lineinfo,n,sizeof(int),D);
116 |  n= (D->strip) ? 0 : f->sizelocvars;
117 |  DumpInt(n,D);
118 |  for (i=0; i<n; i++)
119 |  {
120 |   DumpString(f->locvars[i].varname,D);
121 |   DumpInt(f->locvars[i].startpc,D);
122 |   DumpInt(f->locvars[i].endpc,D);
123 |  }
124 |  n= (D->strip) ? 0 : f->sizeupvalues;
125 |  DumpInt(n,D);
126 |  for (i=0; i<n; i++) DumpString(f->upvalues[i],D);
127 | }
128 | 
129 | static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
130 | {
131 |  DumpString((f->source==p || D->strip) ? NULL : f->source,D);
132 |  DumpInt(f->linedefined,D);
133 |  DumpInt(f->lastlinedefined,D);
134 |  DumpChar(f->nups,D);
135 |  DumpChar(f->numparams,D);
136 |  DumpChar(f->is_vararg,D);
137 |  DumpChar(f->maxstacksize,D);
138 |  DumpCode(f,D);
139 |  DumpConstants(f,D);
140 |  DumpDebug(f,D);
141 | }
142 | 
143 | static void DumpHeader(DumpState* D)
144 | {
145 |  char h[LUAC_HEADERSIZE];
146 |  luaU_header(h);
147 |  DumpBlock(h,LUAC_HEADERSIZE,D);
148 | }
149 | 
150 | /*
151 | ** dump Lua function as precompiled chunk
152 | */
153 | int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
154 | {
155 |  DumpState D;
156 |  D.L=L;
157 |  D.writer=w;
158 |  D.data=data;
159 |  D.strip=strip;
160 |  D.status=0;
161 |  DumpHeader(&D);
162 |  DumpFunction(f,NULL,&D);
163 |  return D.status;
164 | }
165 | 


--------------------------------------------------------------------------------
/lua52/ldump.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: ldump.c,v 2.17.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** save precompiled Lua chunks
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #include <stddef.h>
  8 | 
  9 | #define ldump_c
 10 | #define LUA_CORE
 11 | 
 12 | #include "lua.h"
 13 | 
 14 | #include "lobject.h"
 15 | #include "lstate.h"
 16 | #include "lundump.h"
 17 | 
 18 | typedef struct {
 19 |  lua_State* L;
 20 |  lua_Writer writer;
 21 |  void* data;
 22 |  int strip;
 23 |  int status;
 24 | } DumpState;
 25 | 
 26 | #define DumpMem(b,n,size,D)	DumpBlock(b,(n)*(size),D)
 27 | #define DumpVar(x,D)		DumpMem(&x,1,sizeof(x),D)
 28 | 
 29 | static void DumpBlock(const void* b, size_t size, DumpState* D)
 30 | {
 31 |  if (D->status==0)
 32 |  {
 33 |   lua_unlock(D->L);
 34 |   D->status=(*D->writer)(D->L,b,size,D->data);
 35 |   lua_lock(D->L);
 36 |  }
 37 | }
 38 | 
 39 | static void DumpChar(int y, DumpState* D)
 40 | {
 41 |  char x=(char)y;
 42 |  DumpVar(x,D);
 43 | }
 44 | 
 45 | static void DumpInt(int x, DumpState* D)
 46 | {
 47 |  DumpVar(x,D);
 48 | }
 49 | 
 50 | static void DumpNumber(lua_Number x, DumpState* D)
 51 | {
 52 |  DumpVar(x,D);
 53 | }
 54 | 
 55 | static void DumpVector(const void* b, int n, size_t size, DumpState* D)
 56 | {
 57 |  DumpInt(n,D);
 58 |  DumpMem(b,n,size,D);
 59 | }
 60 | 
 61 | static void DumpString(const TString* s, DumpState* D)
 62 | {
 63 |  if (s==NULL)
 64 |  {
 65 |   size_t size=0;
 66 |   DumpVar(size,D);
 67 |  }
 68 |  else
 69 |  {
 70 |   size_t size=s->tsv.len+1;		/* include trailing '\0' */
 71 |   DumpVar(size,D);
 72 |   DumpBlock(getstr(s),size*sizeof(char),D);
 73 |  }
 74 | }
 75 | 
 76 | #define DumpCode(f,D)	 DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
 77 | 
 78 | static void DumpFunction(const Proto* f, DumpState* D);
 79 | 
 80 | static void DumpConstants(const Proto* f, DumpState* D)
 81 | {
 82 |  int i,n=f->sizek;
 83 |  DumpInt(n,D);
 84 |  for (i=0; i<n; i++)
 85 |  {
 86 |   const TValue* o=&f->k[i];
 87 |   DumpChar(ttypenv(o),D);
 88 |   switch (ttypenv(o))
 89 |   {
 90 |    case LUA_TNIL:
 91 | 	break;
 92 |    case LUA_TBOOLEAN:
 93 | 	DumpChar(bvalue(o),D);
 94 | 	break;
 95 |    case LUA_TNUMBER:
 96 | 	DumpNumber(nvalue(o),D);
 97 | 	break;
 98 |    case LUA_TSTRING:
 99 | 	DumpString(rawtsvalue(o),D);
100 | 	break;
101 |     default: lua_assert(0);
102 |   }
103 |  }
104 |  n=f->sizep;
105 |  DumpInt(n,D);
106 |  for (i=0; i<n; i++) DumpFunction(f->p[i],D);
107 | }
108 | 
109 | static void DumpUpvalues(const Proto* f, DumpState* D)
110 | {
111 |  int i,n=f->sizeupvalues;
112 |  DumpInt(n,D);
113 |  for (i=0; i<n; i++)
114 |  {
115 |   DumpChar(f->upvalues[i].instack,D);
116 |   DumpChar(f->upvalues[i].idx,D);
117 |  }
118 | }
119 | 
120 | static void DumpDebug(const Proto* f, DumpState* D)
121 | {
122 |  int i,n;
123 |  DumpString((D->strip) ? NULL : f->source,D);
124 |  n= (D->strip) ? 0 : f->sizelineinfo;
125 |  DumpVector(f->lineinfo,n,sizeof(int),D);
126 |  n= (D->strip) ? 0 : f->sizelocvars;
127 |  DumpInt(n,D);
128 |  for (i=0; i<n; i++)
129 |  {
130 |   DumpString(f->locvars[i].varname,D);
131 |   DumpInt(f->locvars[i].startpc,D);
132 |   DumpInt(f->locvars[i].endpc,D);
133 |  }
134 |  n= (D->strip) ? 0 : f->sizeupvalues;
135 |  DumpInt(n,D);
136 |  for (i=0; i<n; i++) DumpString(f->upvalues[i].name,D);
137 | }
138 | 
139 | static void DumpFunction(const Proto* f, DumpState* D)
140 | {
141 |  DumpInt(f->linedefined,D);
142 |  DumpInt(f->lastlinedefined,D);
143 |  DumpChar(f->numparams,D);
144 |  DumpChar(f->is_vararg,D);
145 |  DumpChar(f->maxstacksize,D);
146 |  DumpCode(f,D);
147 |  DumpConstants(f,D);
148 |  DumpUpvalues(f,D);
149 |  DumpDebug(f,D);
150 | }
151 | 
152 | static void DumpHeader(DumpState* D)
153 | {
154 |  lu_byte h[LUAC_HEADERSIZE];
155 |  luaU_header(h);
156 |  DumpBlock(h,LUAC_HEADERSIZE,D);
157 | }
158 | 
159 | /*
160 | ** dump Lua function as precompiled chunk
161 | */
162 | int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
163 | {
164 |  DumpState D;
165 |  D.L=L;
166 |  D.writer=w;
167 |  D.data=data;
168 |  D.strip=strip;
169 |  D.status=0;
170 |  DumpHeader(&D);
171 |  DumpFunction(f,&D);
172 |  return D.status;
173 | }
174 | 


--------------------------------------------------------------------------------
/lua53/lopcodes.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lopcodes.c,v 1.55.1.1 2017/04/19 17:20:42 roberto Exp $
  3 | ** Opcodes for Lua virtual machine
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #define lopcodes_c
  8 | #define LUA_CORE
  9 | 
 10 | #include "lprefix.h"
 11 | 
 12 | 
 13 | #include <stddef.h>
 14 | 
 15 | #include "lopcodes.h"
 16 | 
 17 | 
 18 | /* ORDER OP */
 19 | 
 20 | LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
 21 |   "MOVE",
 22 |   "LOADK",
 23 |   "LOADKX",
 24 |   "LOADBOOL",
 25 |   "LOADNIL",
 26 |   "GETUPVAL",
 27 |   "GETTABUP",
 28 |   "GETTABLE",
 29 |   "SETTABUP",
 30 |   "SETUPVAL",
 31 |   "SETTABLE",
 32 |   "NEWTABLE",
 33 |   "SELF",
 34 |   "ADD",
 35 |   "SUB",
 36 |   "MUL",
 37 |   "MOD",
 38 |   "POW",
 39 |   "DIV",
 40 |   "IDIV",
 41 |   "BAND",
 42 |   "BOR",
 43 |   "BXOR",
 44 |   "SHL",
 45 |   "SHR",
 46 |   "UNM",
 47 |   "BNOT",
 48 |   "NOT",
 49 |   "LEN",
 50 |   "CONCAT",
 51 |   "JMP",
 52 |   "EQ",
 53 |   "LT",
 54 |   "LE",
 55 |   "TEST",
 56 |   "TESTSET",
 57 |   "CALL",
 58 |   "TAILCALL",
 59 |   "RETURN",
 60 |   "FORLOOP",
 61 |   "FORPREP",
 62 |   "TFORCALL",
 63 |   "TFORLOOP",
 64 |   "SETLIST",
 65 |   "CLOSURE",
 66 |   "VARARG",
 67 |   "EXTRAARG",
 68 |   NULL
 69 | };
 70 | 
 71 | 
 72 | #define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
 73 | 
 74 | LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
 75 | /*       T  A    B       C     mode		   opcode	*/
 76 |   opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_MOVE */
 77 |  ,opmode(0, 1, OpArgK, OpArgN, iABx)		/* OP_LOADK */
 78 |  ,opmode(0, 1, OpArgN, OpArgN, iABx)		/* OP_LOADKX */
 79 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_LOADBOOL */
 80 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_LOADNIL */
 81 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_GETUPVAL */
 82 |  ,opmode(0, 1, OpArgU, OpArgK, iABC)		/* OP_GETTABUP */
 83 |  ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_GETTABLE */
 84 |  ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABUP */
 85 |  ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_SETUPVAL */
 86 |  ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABLE */
 87 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_NEWTABLE */
 88 |  ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_SELF */
 89 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_ADD */
 90 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SUB */
 91 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MUL */
 92 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MOD */
 93 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_POW */
 94 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
 95 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_IDIV */
 96 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BAND */
 97 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BOR */
 98 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BXOR */
 99 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SHL */
100 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SHR */
101 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_UNM */
102 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_BNOT */
103 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_NOT */
104 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LEN */
105 |  ,opmode(0, 1, OpArgR, OpArgR, iABC)		/* OP_CONCAT */
106 |  ,opmode(0, 0, OpArgR, OpArgN, iAsBx)		/* OP_JMP */
107 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_EQ */
108 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LT */
109 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LE */
110 |  ,opmode(1, 0, OpArgN, OpArgU, iABC)		/* OP_TEST */
111 |  ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TESTSET */
112 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_CALL */
113 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_TAILCALL */
114 |  ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_RETURN */
115 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORLOOP */
116 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORPREP */
117 |  ,opmode(0, 0, OpArgN, OpArgU, iABC)		/* OP_TFORCALL */
118 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_TFORLOOP */
119 |  ,opmode(0, 0, OpArgU, OpArgU, iABC)		/* OP_SETLIST */
120 |  ,opmode(0, 1, OpArgU, OpArgN, iABx)		/* OP_CLOSURE */
121 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_VARARG */
122 |  ,opmode(0, 0, OpArgU, OpArgU, iAx)		/* OP_EXTRAARG */
123 | };
124 | 
125 | 


--------------------------------------------------------------------------------
/lua53/lvm.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lvm.h,v 2.41.1.1 2017/04/19 17:20:42 roberto Exp $
  3 | ** Lua virtual machine
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #ifndef lvm_h
  8 | #define lvm_h
  9 | 
 10 | 
 11 | #include "ldo.h"
 12 | #include "lobject.h"
 13 | #include "ltm.h"
 14 | 
 15 | 
 16 | #if !defined(LUA_NOCVTN2S)
 17 | #define cvt2str(o)	ttisnumber(o)
 18 | #else
 19 | #define cvt2str(o)	0	/* no conversion from numbers to strings */
 20 | #endif
 21 | 
 22 | 
 23 | #if !defined(LUA_NOCVTS2N)
 24 | #define cvt2num(o)	ttisstring(o)
 25 | #else
 26 | #define cvt2num(o)	0	/* no conversion from strings to numbers */
 27 | #endif
 28 | 
 29 | 
 30 | /*
 31 | ** You can define LUA_FLOORN2I if you want to convert floats to integers
 32 | ** by flooring them (instead of raising an error if they are not
 33 | ** integral values)
 34 | */
 35 | #if !defined(LUA_FLOORN2I)
 36 | #define LUA_FLOORN2I		0
 37 | #endif
 38 | 
 39 | 
 40 | #define tonumber(o,n) \
 41 | 	(ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n))
 42 | 
 43 | #define tointeger(o,i) \
 44 |     (ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointeger(o,i,LUA_FLOORN2I))
 45 | 
 46 | #define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2))
 47 | 
 48 | #define luaV_rawequalobj(t1,t2)		luaV_equalobj(NULL,t1,t2)
 49 | 
 50 | 
 51 | /*
 52 | ** fast track for 'gettable': if 't' is a table and 't[k]' is not nil,
 53 | ** return 1 with 'slot' pointing to 't[k]' (final result).  Otherwise,
 54 | ** return 0 (meaning it will have to check metamethod) with 'slot'
 55 | ** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise).
 56 | ** 'f' is the raw get function to use.
 57 | */
 58 | #define luaV_fastget(L,t,k,slot,f) \
 59 |   (!ttistable(t)  \
 60 |    ? (slot = NULL, 0)  /* not a table; 'slot' is NULL and result is 0 */  \
 61 |    : (slot = f(hvalue(t), k),  /* else, do raw access */  \
 62 |       !ttisnil(slot)))  /* result not nil? */
 63 | 
 64 | /*
 65 | ** standard implementation for 'gettable'
 66 | */
 67 | #define luaV_gettable(L,t,k,v) { const TValue *slot; \
 68 |   if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
 69 |   else luaV_finishget(L,t,k,v,slot); }
 70 | 
 71 | 
 72 | /*
 73 | ** Fast track for set table. If 't' is a table and 't[k]' is not nil,
 74 | ** call GC barrier, do a raw 't[k]=v', and return true; otherwise,
 75 | ** return false with 'slot' equal to NULL (if 't' is not a table) or
 76 | ** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro
 77 | ** returns true, there is no need to 'invalidateTMcache', because the
 78 | ** call is not creating a new entry.
 79 | */
 80 | #define luaV_fastset(L,t,k,slot,f,v) \
 81 |   (!ttistable(t) \
 82 |    ? (slot = NULL, 0) \
 83 |    : (slot = f(hvalue(t), k), \
 84 |      ttisnil(slot) ? 0 \
 85 |      : (luaC_barrierback(L, hvalue(t), v), \
 86 |         setobj2t(L, cast(TValue *,slot), v), \
 87 |         1)))
 88 | 
 89 | 
 90 | #define luaV_settable(L,t,k,v) { const TValue *slot; \
 91 |   if (!luaV_fastset(L,t,k,slot,luaH_get,v)) \
 92 |     luaV_finishset(L,t,k,v,slot); }
 93 | 
 94 | 
 95 | 
 96 | LUAI_FUNC int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2);
 97 | LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
 98 | LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r);
 99 | LUAI_FUNC int luaV_tonumber_ (const TValue *obj, lua_Number *n);
100 | LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode);
101 | LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key,
102 |                                StkId val, const TValue *slot);
103 | LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
104 |                                StkId val, const TValue *slot);
105 | LUAI_FUNC void luaV_finishOp (lua_State *L);
106 | LUAI_FUNC void luaV_execute (lua_State *L);
107 | LUAI_FUNC void luaV_concat (lua_State *L, int total);
108 | LUAI_FUNC lua_Integer luaV_div (lua_State *L, lua_Integer x, lua_Integer y);
109 | LUAI_FUNC lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y);
110 | LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y);
111 | LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb);
112 | 
113 | #endif
114 | 


--------------------------------------------------------------------------------
/lua52/lcorolib.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lcorolib.c,v 1.5.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Coroutine Library
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <stdlib.h>
  9 | 
 10 | 
 11 | #define lcorolib_c
 12 | #define LUA_LIB
 13 | 
 14 | #include "lua.h"
 15 | 
 16 | #include "lauxlib.h"
 17 | #include "lualib.h"
 18 | 
 19 | 
 20 | static int auxresume (lua_State *L, lua_State *co, int narg) {
 21 |   int status;
 22 |   if (!lua_checkstack(co, narg)) {
 23 |     lua_pushliteral(L, "too many arguments to resume");
 24 |     return -1;  /* error flag */
 25 |   }
 26 |   if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) {
 27 |     lua_pushliteral(L, "cannot resume dead coroutine");
 28 |     return -1;  /* error flag */
 29 |   }
 30 |   lua_xmove(L, co, narg);
 31 |   status = lua_resume(co, L, narg);
 32 |   if (status == LUA_OK || status == LUA_YIELD) {
 33 |     int nres = lua_gettop(co);
 34 |     if (!lua_checkstack(L, nres + 1)) {
 35 |       lua_pop(co, nres);  /* remove results anyway */
 36 |       lua_pushliteral(L, "too many results to resume");
 37 |       return -1;  /* error flag */
 38 |     }
 39 |     lua_xmove(co, L, nres);  /* move yielded values */
 40 |     return nres;
 41 |   }
 42 |   else {
 43 |     lua_xmove(co, L, 1);  /* move error message */
 44 |     return -1;  /* error flag */
 45 |   }
 46 | }
 47 | 
 48 | 
 49 | static int luaB_coresume (lua_State *L) {
 50 |   lua_State *co = lua_tothread(L, 1);
 51 |   int r;
 52 |   luaL_argcheck(L, co, 1, "coroutine expected");
 53 |   r = auxresume(L, co, lua_gettop(L) - 1);
 54 |   if (r < 0) {
 55 |     lua_pushboolean(L, 0);
 56 |     lua_insert(L, -2);
 57 |     return 2;  /* return false + error message */
 58 |   }
 59 |   else {
 60 |     lua_pushboolean(L, 1);
 61 |     lua_insert(L, -(r + 1));
 62 |     return r + 1;  /* return true + `resume' returns */
 63 |   }
 64 | }
 65 | 
 66 | 
 67 | static int luaB_auxwrap (lua_State *L) {
 68 |   lua_State *co = lua_tothread(L, lua_upvalueindex(1));
 69 |   int r = auxresume(L, co, lua_gettop(L));
 70 |   if (r < 0) {
 71 |     if (lua_isstring(L, -1)) {  /* error object is a string? */
 72 |       luaL_where(L, 1);  /* add extra info */
 73 |       lua_insert(L, -2);
 74 |       lua_concat(L, 2);
 75 |     }
 76 |     return lua_error(L);  /* propagate error */
 77 |   }
 78 |   return r;
 79 | }
 80 | 
 81 | 
 82 | static int luaB_cocreate (lua_State *L) {
 83 |   lua_State *NL;
 84 |   luaL_checktype(L, 1, LUA_TFUNCTION);
 85 |   NL = lua_newthread(L);
 86 |   lua_pushvalue(L, 1);  /* move function to top */
 87 |   lua_xmove(L, NL, 1);  /* move function from L to NL */
 88 |   return 1;
 89 | }
 90 | 
 91 | 
 92 | static int luaB_cowrap (lua_State *L) {
 93 |   luaB_cocreate(L);
 94 |   lua_pushcclosure(L, luaB_auxwrap, 1);
 95 |   return 1;
 96 | }
 97 | 
 98 | 
 99 | static int luaB_yield (lua_State *L) {
100 |   return lua_yield(L, lua_gettop(L));
101 | }
102 | 
103 | 
104 | static int luaB_costatus (lua_State *L) {
105 |   lua_State *co = lua_tothread(L, 1);
106 |   luaL_argcheck(L, co, 1, "coroutine expected");
107 |   if (L == co) lua_pushliteral(L, "running");
108 |   else {
109 |     switch (lua_status(co)) {
110 |       case LUA_YIELD:
111 |         lua_pushliteral(L, "suspended");
112 |         break;
113 |       case LUA_OK: {
114 |         lua_Debug ar;
115 |         if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
116 |           lua_pushliteral(L, "normal");  /* it is running */
117 |         else if (lua_gettop(co) == 0)
118 |             lua_pushliteral(L, "dead");
119 |         else
120 |           lua_pushliteral(L, "suspended");  /* initial state */
121 |         break;
122 |       }
123 |       default:  /* some error occurred */
124 |         lua_pushliteral(L, "dead");
125 |         break;
126 |     }
127 |   }
128 |   return 1;
129 | }
130 | 
131 | 
132 | static int luaB_corunning (lua_State *L) {
133 |   int ismain = lua_pushthread(L);
134 |   lua_pushboolean(L, ismain);
135 |   return 2;
136 | }
137 | 
138 | 
139 | static const luaL_Reg co_funcs[] = {
140 |   {"create", luaB_cocreate},
141 |   {"resume", luaB_coresume},
142 |   {"running", luaB_corunning},
143 |   {"status", luaB_costatus},
144 |   {"wrap", luaB_cowrap},
145 |   {"yield", luaB_yield},
146 |   {NULL, NULL}
147 | };
148 | 
149 | 
150 | 
151 | LUAMOD_API int luaopen_coroutine (lua_State *L) {
152 |   luaL_newlib(L, co_funcs);
153 |   return 1;
154 | }
155 | 
156 | 


--------------------------------------------------------------------------------
/lua53/lfunc.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lfunc.c,v 2.45.1.1 2017/04/19 17:39:34 roberto Exp $
  3 | ** Auxiliary functions to manipulate prototypes and closures
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #define lfunc_c
  8 | #define LUA_CORE
  9 | 
 10 | #include "lprefix.h"
 11 | 
 12 | 
 13 | #include <stddef.h>
 14 | 
 15 | #include "lua.h"
 16 | 
 17 | #include "lfunc.h"
 18 | #include "lgc.h"
 19 | #include "lmem.h"
 20 | #include "lobject.h"
 21 | #include "lstate.h"
 22 | 
 23 | 
 24 | 
 25 | CClosure *luaF_newCclosure (lua_State *L, int n) {
 26 |   GCObject *o = luaC_newobj(L, LUA_TCCL, sizeCclosure(n));
 27 |   CClosure *c = gco2ccl(o);
 28 |   c->nupvalues = cast_byte(n);
 29 |   return c;
 30 | }
 31 | 
 32 | 
 33 | LClosure *luaF_newLclosure (lua_State *L, int n) {
 34 |   GCObject *o = luaC_newobj(L, LUA_TLCL, sizeLclosure(n));
 35 |   LClosure *c = gco2lcl(o);
 36 |   c->p = NULL;
 37 |   c->nupvalues = cast_byte(n);
 38 |   while (n--) c->upvals[n] = NULL;
 39 |   return c;
 40 | }
 41 | 
 42 | /*
 43 | ** fill a closure with new closed upvalues
 44 | */
 45 | void luaF_initupvals (lua_State *L, LClosure *cl) {
 46 |   int i;
 47 |   for (i = 0; i < cl->nupvalues; i++) {
 48 |     UpVal *uv = luaM_new(L, UpVal);
 49 |     uv->refcount = 1;
 50 |     uv->v = &uv->u.value;  /* make it closed */
 51 |     setnilvalue(uv->v);
 52 |     cl->upvals[i] = uv;
 53 |   }
 54 | }
 55 | 
 56 | 
 57 | UpVal *luaF_findupval (lua_State *L, StkId level) {
 58 |   UpVal **pp = &L->openupval;
 59 |   UpVal *p;
 60 |   UpVal *uv;
 61 |   lua_assert(isintwups(L) || L->openupval == NULL);
 62 |   while (*pp != NULL && (p = *pp)->v >= level) {
 63 |     lua_assert(upisopen(p));
 64 |     if (p->v == level)  /* found a corresponding upvalue? */
 65 |       return p;  /* return it */
 66 |     pp = &p->u.open.next;
 67 |   }
 68 |   /* not found: create a new upvalue */
 69 |   uv = luaM_new(L, UpVal);
 70 |   uv->refcount = 0;
 71 |   uv->u.open.next = *pp;  /* link it to list of open upvalues */
 72 |   uv->u.open.touched = 1;
 73 |   *pp = uv;
 74 |   uv->v = level;  /* current value lives in the stack */
 75 |   if (!isintwups(L)) {  /* thread not in list of threads with upvalues? */
 76 |     L->twups = G(L)->twups;  /* link it to the list */
 77 |     G(L)->twups = L;
 78 |   }
 79 |   return uv;
 80 | }
 81 | 
 82 | 
 83 | void luaF_close (lua_State *L, StkId level) {
 84 |   UpVal *uv;
 85 |   while (L->openupval != NULL && (uv = L->openupval)->v >= level) {
 86 |     lua_assert(upisopen(uv));
 87 |     L->openupval = uv->u.open.next;  /* remove from 'open' list */
 88 |     if (uv->refcount == 0)  /* no references? */
 89 |       luaM_free(L, uv);  /* free upvalue */
 90 |     else {
 91 |       setobj(L, &uv->u.value, uv->v);  /* move value to upvalue slot */
 92 |       uv->v = &uv->u.value;  /* now current value lives here */
 93 |       luaC_upvalbarrier(L, uv);
 94 |     }
 95 |   }
 96 | }
 97 | 
 98 | 
 99 | Proto *luaF_newproto (lua_State *L) {
100 |   GCObject *o = luaC_newobj(L, LUA_TPROTO, sizeof(Proto));
101 |   Proto *f = gco2p(o);
102 |   f->k = NULL;
103 |   f->sizek = 0;
104 |   f->p = NULL;
105 |   f->sizep = 0;
106 |   f->code = NULL;
107 |   f->cache = NULL;
108 |   f->sizecode = 0;
109 |   f->lineinfo = NULL;
110 |   f->sizelineinfo = 0;
111 |   f->upvalues = NULL;
112 |   f->sizeupvalues = 0;
113 |   f->numparams = 0;
114 |   f->is_vararg = 0;
115 |   f->maxstacksize = 0;
116 |   f->locvars = NULL;
117 |   f->sizelocvars = 0;
118 |   f->linedefined = 0;
119 |   f->lastlinedefined = 0;
120 |   f->source = NULL;
121 |   return f;
122 | }
123 | 
124 | 
125 | void luaF_freeproto (lua_State *L, Proto *f) {
126 |   luaM_freearray(L, f->code, f->sizecode);
127 |   luaM_freearray(L, f->p, f->sizep);
128 |   luaM_freearray(L, f->k, f->sizek);
129 |   luaM_freearray(L, f->lineinfo, f->sizelineinfo);
130 |   luaM_freearray(L, f->locvars, f->sizelocvars);
131 |   luaM_freearray(L, f->upvalues, f->sizeupvalues);
132 |   luaM_free(L, f);
133 | }
134 | 
135 | 
136 | /*
137 | ** Look for n-th local variable at line 'line' in function 'func'.
138 | ** Returns NULL if not found.
139 | */
140 | const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
141 |   int i;
142 |   for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
143 |     if (pc < f->locvars[i].endpc) {  /* is variable active? */
144 |       local_number--;
145 |       if (local_number == 0)
146 |         return getstr(f->locvars[i].varname);
147 |     }
148 |   }
149 |   return NULL;  /* not found */
150 | }
151 | 
152 | 


--------------------------------------------------------------------------------
/lua53/lcorolib.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lcorolib.c,v 1.10.1.1 2017/04/19 17:20:42 roberto Exp $
  3 | ** Coroutine Library
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #define lcorolib_c
  8 | #define LUA_LIB
  9 | 
 10 | #include "lprefix.h"
 11 | 
 12 | 
 13 | #include <stdlib.h>
 14 | 
 15 | #include "lua.h"
 16 | 
 17 | #include "lauxlib.h"
 18 | #include "lualib.h"
 19 | 
 20 | 
 21 | static lua_State *getco (lua_State *L) {
 22 |   lua_State *co = lua_tothread(L, 1);
 23 |   luaL_argcheck(L, co, 1, "thread expected");
 24 |   return co;
 25 | }
 26 | 
 27 | 
 28 | static int auxresume (lua_State *L, lua_State *co, int narg) {
 29 |   int status;
 30 |   if (!lua_checkstack(co, narg)) {
 31 |     lua_pushliteral(L, "too many arguments to resume");
 32 |     return -1;  /* error flag */
 33 |   }
 34 |   if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) {
 35 |     lua_pushliteral(L, "cannot resume dead coroutine");
 36 |     return -1;  /* error flag */
 37 |   }
 38 |   lua_xmove(L, co, narg);
 39 |   status = lua_resume(co, L, narg);
 40 |   if (status == LUA_OK || status == LUA_YIELD) {
 41 |     int nres = lua_gettop(co);
 42 |     if (!lua_checkstack(L, nres + 1)) {
 43 |       lua_pop(co, nres);  /* remove results anyway */
 44 |       lua_pushliteral(L, "too many results to resume");
 45 |       return -1;  /* error flag */
 46 |     }
 47 |     lua_xmove(co, L, nres);  /* move yielded values */
 48 |     return nres;
 49 |   }
 50 |   else {
 51 |     lua_xmove(co, L, 1);  /* move error message */
 52 |     return -1;  /* error flag */
 53 |   }
 54 | }
 55 | 
 56 | 
 57 | static int luaB_coresume (lua_State *L) {
 58 |   lua_State *co = getco(L);
 59 |   int r;
 60 |   r = auxresume(L, co, lua_gettop(L) - 1);
 61 |   if (r < 0) {
 62 |     lua_pushboolean(L, 0);
 63 |     lua_insert(L, -2);
 64 |     return 2;  /* return false + error message */
 65 |   }
 66 |   else {
 67 |     lua_pushboolean(L, 1);
 68 |     lua_insert(L, -(r + 1));
 69 |     return r + 1;  /* return true + 'resume' returns */
 70 |   }
 71 | }
 72 | 
 73 | 
 74 | static int luaB_auxwrap (lua_State *L) {
 75 |   lua_State *co = lua_tothread(L, lua_upvalueindex(1));
 76 |   int r = auxresume(L, co, lua_gettop(L));
 77 |   if (r < 0) {
 78 |     if (lua_type(L, -1) == LUA_TSTRING) {  /* error object is a string? */
 79 |       luaL_where(L, 1);  /* add extra info */
 80 |       lua_insert(L, -2);
 81 |       lua_concat(L, 2);
 82 |     }
 83 |     return lua_error(L);  /* propagate error */
 84 |   }
 85 |   return r;
 86 | }
 87 | 
 88 | 
 89 | static int luaB_cocreate (lua_State *L) {
 90 |   lua_State *NL;
 91 |   luaL_checktype(L, 1, LUA_TFUNCTION);
 92 |   NL = lua_newthread(L);
 93 |   lua_pushvalue(L, 1);  /* move function to top */
 94 |   lua_xmove(L, NL, 1);  /* move function from L to NL */
 95 |   return 1;
 96 | }
 97 | 
 98 | 
 99 | static int luaB_cowrap (lua_State *L) {
100 |   luaB_cocreate(L);
101 |   lua_pushcclosure(L, luaB_auxwrap, 1);
102 |   return 1;
103 | }
104 | 
105 | 
106 | static int luaB_yield (lua_State *L) {
107 |   return lua_yield(L, lua_gettop(L));
108 | }
109 | 
110 | 
111 | static int luaB_costatus (lua_State *L) {
112 |   lua_State *co = getco(L);
113 |   if (L == co) lua_pushliteral(L, "running");
114 |   else {
115 |     switch (lua_status(co)) {
116 |       case LUA_YIELD:
117 |         lua_pushliteral(L, "suspended");
118 |         break;
119 |       case LUA_OK: {
120 |         lua_Debug ar;
121 |         if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
122 |           lua_pushliteral(L, "normal");  /* it is running */
123 |         else if (lua_gettop(co) == 0)
124 |             lua_pushliteral(L, "dead");
125 |         else
126 |           lua_pushliteral(L, "suspended");  /* initial state */
127 |         break;
128 |       }
129 |       default:  /* some error occurred */
130 |         lua_pushliteral(L, "dead");
131 |         break;
132 |     }
133 |   }
134 |   return 1;
135 | }
136 | 
137 | 
138 | static int luaB_yieldable (lua_State *L) {
139 |   lua_pushboolean(L, lua_isyieldable(L));
140 |   return 1;
141 | }
142 | 
143 | 
144 | static int luaB_corunning (lua_State *L) {
145 |   int ismain = lua_pushthread(L);
146 |   lua_pushboolean(L, ismain);
147 |   return 2;
148 | }
149 | 
150 | 
151 | static const luaL_Reg co_funcs[] = {
152 |   {"create", luaB_cocreate},
153 |   {"resume", luaB_coresume},
154 |   {"running", luaB_corunning},
155 |   {"status", luaB_costatus},
156 |   {"wrap", luaB_cowrap},
157 |   {"yield", luaB_yield},
158 |   {"isyieldable", luaB_yieldable},
159 |   {NULL, NULL}
160 | };
161 | 
162 | 
163 | 
164 | LUAMOD_API int luaopen_coroutine (lua_State *L) {
165 |   luaL_newlib(L, co_funcs);
166 |   return 1;
167 | }
168 | 
169 | 


--------------------------------------------------------------------------------
/lua53/lparser.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lparser.h,v 1.76.1.1 2017/04/19 17:20:42 roberto Exp $
  3 | ** Lua Parser
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #ifndef lparser_h
  8 | #define lparser_h
  9 | 
 10 | #include "llimits.h"
 11 | #include "lobject.h"
 12 | #include "lzio.h"
 13 | 
 14 | 
 15 | /*
 16 | ** Expression and variable descriptor.
 17 | ** Code generation for variables and expressions can be delayed to allow
 18 | ** optimizations; An 'expdesc' structure describes a potentially-delayed
 19 | ** variable/expression. It has a description of its "main" value plus a
 20 | ** list of conditional jumps that can also produce its value (generated
 21 | ** by short-circuit operators 'and'/'or').
 22 | */
 23 | 
 24 | /* kinds of variables/expressions */
 25 | typedef enum {
 26 |   VVOID,  /* when 'expdesc' describes the last expression a list,
 27 |              this kind means an empty list (so, no expression) */
 28 |   VNIL,  /* constant nil */
 29 |   VTRUE,  /* constant true */
 30 |   VFALSE,  /* constant false */
 31 |   VK,  /* constant in 'k'; info = index of constant in 'k' */
 32 |   VKFLT,  /* floating constant; nval = numerical float value */
 33 |   VKINT,  /* integer constant; nval = numerical integer value */
 34 |   VNONRELOC,  /* expression has its value in a fixed register;
 35 |                  info = result register */
 36 |   VLOCAL,  /* local variable; info = local register */
 37 |   VUPVAL,  /* upvalue variable; info = index of upvalue in 'upvalues' */
 38 |   VINDEXED,  /* indexed variable;
 39 |                 ind.vt = whether 't' is register or upvalue;
 40 |                 ind.t = table register or upvalue;
 41 |                 ind.idx = key's R/K index */
 42 |   VJMP,  /* expression is a test/comparison;
 43 |             info = pc of corresponding jump instruction */
 44 |   VRELOCABLE,  /* expression can put result in any register;
 45 |                   info = instruction pc */
 46 |   VCALL,  /* expression is a function call; info = instruction pc */
 47 |   VVARARG  /* vararg expression; info = instruction pc */
 48 | } expkind;
 49 | 
 50 | 
 51 | #define vkisvar(k)	(VLOCAL <= (k) && (k) <= VINDEXED)
 52 | #define vkisinreg(k)	((k) == VNONRELOC || (k) == VLOCAL)
 53 | 
 54 | typedef struct expdesc {
 55 |   expkind k;
 56 |   union {
 57 |     lua_Integer ival;    /* for VKINT */
 58 |     lua_Number nval;  /* for VKFLT */
 59 |     int info;  /* for generic use */
 60 |     struct {  /* for indexed variables (VINDEXED) */
 61 |       short idx;  /* index (R/K) */
 62 |       lu_byte t;  /* table (register or upvalue) */
 63 |       lu_byte vt;  /* whether 't' is register (VLOCAL) or upvalue (VUPVAL) */
 64 |     } ind;
 65 |   } u;
 66 |   int t;  /* patch list of 'exit when true' */
 67 |   int f;  /* patch list of 'exit when false' */
 68 | } expdesc;
 69 | 
 70 | 
 71 | /* description of active local variable */
 72 | typedef struct Vardesc {
 73 |   short idx;  /* variable index in stack */
 74 | } Vardesc;
 75 | 
 76 | 
 77 | /* description of pending goto statements and label statements */
 78 | typedef struct Labeldesc {
 79 |   TString *name;  /* label identifier */
 80 |   int pc;  /* position in code */
 81 |   int line;  /* line where it appeared */
 82 |   lu_byte nactvar;  /* local level where it appears in current block */
 83 | } Labeldesc;
 84 | 
 85 | 
 86 | /* list of labels or gotos */
 87 | typedef struct Labellist {
 88 |   Labeldesc *arr;  /* array */
 89 |   int n;  /* number of entries in use */
 90 |   int size;  /* array size */
 91 | } Labellist;
 92 | 
 93 | 
 94 | /* dynamic structures used by the parser */
 95 | typedef struct Dyndata {
 96 |   struct {  /* list of active local variables */
 97 |     Vardesc *arr;
 98 |     int n;
 99 |     int size;
100 |   } actvar;
101 |   Labellist gt;  /* list of pending gotos */
102 |   Labellist label;   /* list of active labels */
103 | } Dyndata;
104 | 
105 | 
106 | /* control of blocks */
107 | struct BlockCnt;  /* defined in lparser.c */
108 | 
109 | 
110 | /* state needed to generate code for a given function */
111 | typedef struct FuncState {
112 |   Proto *f;  /* current function header */
113 |   struct FuncState *prev;  /* enclosing function */
114 |   struct LexState *ls;  /* lexical state */
115 |   struct BlockCnt *bl;  /* chain of current blocks */
116 |   int pc;  /* next position to code (equivalent to 'ncode') */
117 |   int lasttarget;   /* 'label' of last 'jump label' */
118 |   int jpc;  /* list of pending jumps to 'pc' */
119 |   int nk;  /* number of elements in 'k' */
120 |   int np;  /* number of elements in 'p' */
121 |   int firstlocal;  /* index of first local var (in Dyndata array) */
122 |   short nlocvars;  /* number of elements in 'f->locvars' */
123 |   lu_byte nactvar;  /* number of active local variables */
124 |   lu_byte nups;  /* number of upvalues */
125 |   lu_byte freereg;  /* first free register */
126 | } FuncState;
127 | 
128 | 
129 | LUAI_FUNC LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
130 |                                  Dyndata *dyd, const char *name, int firstchar);
131 | 
132 | 
133 | #endif
134 | 


--------------------------------------------------------------------------------
/lua52/lfunc.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lfunc.c,v 2.30.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Auxiliary functions to manipulate prototypes and closures
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <stddef.h>
  9 | 
 10 | #define lfunc_c
 11 | #define LUA_CORE
 12 | 
 13 | #include "lua.h"
 14 | 
 15 | #include "lfunc.h"
 16 | #include "lgc.h"
 17 | #include "lmem.h"
 18 | #include "lobject.h"
 19 | #include "lstate.h"
 20 | 
 21 | 
 22 | 
 23 | Closure *luaF_newCclosure (lua_State *L, int n) {
 24 |   Closure *c = &luaC_newobj(L, LUA_TCCL, sizeCclosure(n), NULL, 0)->cl;
 25 |   c->c.nupvalues = cast_byte(n);
 26 |   return c;
 27 | }
 28 | 
 29 | 
 30 | Closure *luaF_newLclosure (lua_State *L, int n) {
 31 |   Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n), NULL, 0)->cl;
 32 |   c->l.p = NULL;
 33 |   c->l.nupvalues = cast_byte(n);
 34 |   while (n--) c->l.upvals[n] = NULL;
 35 |   return c;
 36 | }
 37 | 
 38 | 
 39 | UpVal *luaF_newupval (lua_State *L) {
 40 |   UpVal *uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), NULL, 0)->uv;
 41 |   uv->v = &uv->u.value;
 42 |   setnilvalue(uv->v);
 43 |   return uv;
 44 | }
 45 | 
 46 | 
 47 | UpVal *luaF_findupval (lua_State *L, StkId level) {
 48 |   global_State *g = G(L);
 49 |   GCObject **pp = &L->openupval;
 50 |   UpVal *p;
 51 |   UpVal *uv;
 52 |   while (*pp != NULL && (p = gco2uv(*pp))->v >= level) {
 53 |     GCObject *o = obj2gco(p);
 54 |     lua_assert(p->v != &p->u.value);
 55 |     lua_assert(!isold(o) || isold(obj2gco(L)));
 56 |     if (p->v == level) {  /* found a corresponding upvalue? */
 57 |       if (isdead(g, o))  /* is it dead? */
 58 |         changewhite(o);  /* resurrect it */
 59 |       return p;
 60 |     }
 61 |     pp = &p->next;
 62 |   }
 63 |   /* not found: create a new one */
 64 |   uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), pp, 0)->uv;
 65 |   uv->v = level;  /* current value lives in the stack */
 66 |   uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
 67 |   uv->u.l.next = g->uvhead.u.l.next;
 68 |   uv->u.l.next->u.l.prev = uv;
 69 |   g->uvhead.u.l.next = uv;
 70 |   lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
 71 |   return uv;
 72 | }
 73 | 
 74 | 
 75 | static void unlinkupval (UpVal *uv) {
 76 |   lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
 77 |   uv->u.l.next->u.l.prev = uv->u.l.prev;  /* remove from `uvhead' list */
 78 |   uv->u.l.prev->u.l.next = uv->u.l.next;
 79 | }
 80 | 
 81 | 
 82 | void luaF_freeupval (lua_State *L, UpVal *uv) {
 83 |   if (uv->v != &uv->u.value)  /* is it open? */
 84 |     unlinkupval(uv);  /* remove from open list */
 85 |   luaM_free(L, uv);  /* free upvalue */
 86 | }
 87 | 
 88 | 
 89 | void luaF_close (lua_State *L, StkId level) {
 90 |   UpVal *uv;
 91 |   global_State *g = G(L);
 92 |   while (L->openupval != NULL && (uv = gco2uv(L->openupval))->v >= level) {
 93 |     GCObject *o = obj2gco(uv);
 94 |     lua_assert(!isblack(o) && uv->v != &uv->u.value);
 95 |     L->openupval = uv->next;  /* remove from `open' list */
 96 |     if (isdead(g, o))
 97 |       luaF_freeupval(L, uv);  /* free upvalue */
 98 |     else {
 99 |       unlinkupval(uv);  /* remove upvalue from 'uvhead' list */
100 |       setobj(L, &uv->u.value, uv->v);  /* move value to upvalue slot */
101 |       uv->v = &uv->u.value;  /* now current value lives here */
102 |       gch(o)->next = g->allgc;  /* link upvalue into 'allgc' list */
103 |       g->allgc = o;
104 |       luaC_checkupvalcolor(g, uv);
105 |     }
106 |   }
107 | }
108 | 
109 | 
110 | Proto *luaF_newproto (lua_State *L) {
111 |   Proto *f = &luaC_newobj(L, LUA_TPROTO, sizeof(Proto), NULL, 0)->p;
112 |   f->k = NULL;
113 |   f->sizek = 0;
114 |   f->p = NULL;
115 |   f->sizep = 0;
116 |   f->code = NULL;
117 |   f->cache = NULL;
118 |   f->sizecode = 0;
119 |   f->lineinfo = NULL;
120 |   f->sizelineinfo = 0;
121 |   f->upvalues = NULL;
122 |   f->sizeupvalues = 0;
123 |   f->numparams = 0;
124 |   f->is_vararg = 0;
125 |   f->maxstacksize = 0;
126 |   f->locvars = NULL;
127 |   f->sizelocvars = 0;
128 |   f->linedefined = 0;
129 |   f->lastlinedefined = 0;
130 |   f->source = NULL;
131 |   return f;
132 | }
133 | 
134 | 
135 | void luaF_freeproto (lua_State *L, Proto *f) {
136 |   luaM_freearray(L, f->code, f->sizecode);
137 |   luaM_freearray(L, f->p, f->sizep);
138 |   luaM_freearray(L, f->k, f->sizek);
139 |   luaM_freearray(L, f->lineinfo, f->sizelineinfo);
140 |   luaM_freearray(L, f->locvars, f->sizelocvars);
141 |   luaM_freearray(L, f->upvalues, f->sizeupvalues);
142 |   luaM_free(L, f);
143 | }
144 | 
145 | 
146 | /*
147 | ** Look for n-th local variable at line `line' in function `func'.
148 | ** Returns NULL if not found.
149 | */
150 | const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
151 |   int i;
152 |   for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
153 |     if (pc < f->locvars[i].endpc) {  /* is variable active? */
154 |       local_number--;
155 |       if (local_number == 0)
156 |         return getstr(f->locvars[i].varname);
157 |     }
158 |   }
159 |   return NULL;  /* not found */
160 | }
161 | 
162 | 


--------------------------------------------------------------------------------
/lua53/lgc.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lgc.h,v 2.91.1.1 2017/04/19 17:39:34 roberto Exp $
  3 | ** Garbage Collector
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #ifndef lgc_h
  8 | #define lgc_h
  9 | 
 10 | 
 11 | #include "lobject.h"
 12 | #include "lstate.h"
 13 | 
 14 | /*
 15 | ** Collectable objects may have one of three colors: white, which
 16 | ** means the object is not marked; gray, which means the
 17 | ** object is marked, but its references may be not marked; and
 18 | ** black, which means that the object and all its references are marked.
 19 | ** The main invariant of the garbage collector, while marking objects,
 20 | ** is that a black object can never point to a white one. Moreover,
 21 | ** any gray object must be in a "gray list" (gray, grayagain, weak,
 22 | ** allweak, ephemeron) so that it can be visited again before finishing
 23 | ** the collection cycle. These lists have no meaning when the invariant
 24 | ** is not being enforced (e.g., sweep phase).
 25 | */
 26 | 
 27 | 
 28 | 
 29 | /* how much to allocate before next GC step */
 30 | #if !defined(GCSTEPSIZE)
 31 | /* ~100 small strings */
 32 | #define GCSTEPSIZE	(cast_int(100 * sizeof(TString)))
 33 | #endif
 34 | 
 35 | 
 36 | /*
 37 | ** Possible states of the Garbage Collector
 38 | */
 39 | #define GCSpropagate	0
 40 | #define GCSatomic	1
 41 | #define GCSswpallgc	2
 42 | #define GCSswpfinobj	3
 43 | #define GCSswptobefnz	4
 44 | #define GCSswpend	5
 45 | #define GCScallfin	6
 46 | #define GCSpause	7
 47 | 
 48 | 
 49 | #define issweepphase(g)  \
 50 | 	(GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend)
 51 | 
 52 | 
 53 | /*
 54 | ** macro to tell when main invariant (white objects cannot point to black
 55 | ** ones) must be kept. During a collection, the sweep
 56 | ** phase may break the invariant, as objects turned white may point to
 57 | ** still-black objects. The invariant is restored when sweep ends and
 58 | ** all objects are white again.
 59 | */
 60 | 
 61 | #define keepinvariant(g)	((g)->gcstate <= GCSatomic)
 62 | 
 63 | 
 64 | /*
 65 | ** some useful bit tricks
 66 | */
 67 | #define resetbits(x,m)		((x) &= cast(lu_byte, ~(m)))
 68 | #define setbits(x,m)		((x) |= (m))
 69 | #define testbits(x,m)		((x) & (m))
 70 | #define bitmask(b)		(1<<(b))
 71 | #define bit2mask(b1,b2)		(bitmask(b1) | bitmask(b2))
 72 | #define l_setbit(x,b)		setbits(x, bitmask(b))
 73 | #define resetbit(x,b)		resetbits(x, bitmask(b))
 74 | #define testbit(x,b)		testbits(x, bitmask(b))
 75 | 
 76 | 
 77 | /* Layout for bit use in 'marked' field: */
 78 | #define WHITE0BIT	0  /* object is white (type 0) */
 79 | #define WHITE1BIT	1  /* object is white (type 1) */
 80 | #define BLACKBIT	2  /* object is black */
 81 | #define FINALIZEDBIT	3  /* object has been marked for finalization */
 82 | /* bit 7 is currently used by tests (luaL_checkmemory) */
 83 | 
 84 | #define WHITEBITS	bit2mask(WHITE0BIT, WHITE1BIT)
 85 | 
 86 | 
 87 | #define iswhite(x)      testbits((x)->marked, WHITEBITS)
 88 | #define isblack(x)      testbit((x)->marked, BLACKBIT)
 89 | #define isgray(x)  /* neither white nor black */  \
 90 | 	(!testbits((x)->marked, WHITEBITS | bitmask(BLACKBIT)))
 91 | 
 92 | #define tofinalize(x)	testbit((x)->marked, FINALIZEDBIT)
 93 | 
 94 | #define otherwhite(g)	((g)->currentwhite ^ WHITEBITS)
 95 | #define isdeadm(ow,m)	(!(((m) ^ WHITEBITS) & (ow)))
 96 | #define isdead(g,v)	isdeadm(otherwhite(g), (v)->marked)
 97 | 
 98 | #define changewhite(x)	((x)->marked ^= WHITEBITS)
 99 | #define gray2black(x)	l_setbit((x)->marked, BLACKBIT)
100 | 
101 | #define luaC_white(g)	cast(lu_byte, (g)->currentwhite & WHITEBITS)
102 | 
103 | 
104 | /*
105 | ** Does one step of collection when debt becomes positive. 'pre'/'pos'
106 | ** allows some adjustments to be done only when needed. macro
107 | ** 'condchangemem' is used only for heavy tests (forcing a full
108 | ** GC cycle on every opportunity)
109 | */
110 | #define luaC_condGC(L,pre,pos) \
111 | 	{ if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \
112 | 	  condchangemem(L,pre,pos); }
113 | 
114 | /* more often than not, 'pre'/'pos' are empty */
115 | #define luaC_checkGC(L)		luaC_condGC(L,(void)0,(void)0)
116 | 
117 | 
118 | #define luaC_barrier(L,p,v) (  \
119 | 	(iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ?  \
120 | 	luaC_barrier_(L,obj2gco(p),gcvalue(v)) : cast_void(0))
121 | 
122 | #define luaC_barrierback(L,p,v) (  \
123 | 	(iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \
124 | 	luaC_barrierback_(L,p) : cast_void(0))
125 | 
126 | #define luaC_objbarrier(L,p,o) (  \
127 | 	(isblack(p) && iswhite(o)) ? \
128 | 	luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0))
129 | 
130 | #define luaC_upvalbarrier(L,uv) ( \
131 | 	(iscollectable((uv)->v) && !upisopen(uv)) ? \
132 |          luaC_upvalbarrier_(L,uv) : cast_void(0))
133 | 
134 | LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o);
135 | LUAI_FUNC void luaC_freeallobjects (lua_State *L);
136 | LUAI_FUNC void luaC_step (lua_State *L);
137 | LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
138 | LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
139 | LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz);
140 | LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
141 | LUAI_FUNC void luaC_barrierback_ (lua_State *L, Table *o);
142 | LUAI_FUNC void luaC_upvalbarrier_ (lua_State *L, UpVal *uv);
143 | LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt);
144 | LUAI_FUNC void luaC_upvdeccount (lua_State *L, UpVal *uv);
145 | 
146 | 
147 | #endif
148 | 


--------------------------------------------------------------------------------
/lua52/lbitlib.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lbitlib.c,v 1.18.1.2 2013/07/09 18:01:41 roberto Exp $
  3 | ** Standard library for bitwise operations
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #define lbitlib_c
  8 | #define LUA_LIB
  9 | 
 10 | #include "lua.h"
 11 | 
 12 | #include "lauxlib.h"
 13 | #include "lualib.h"
 14 | 
 15 | 
 16 | /* number of bits to consider in a number */
 17 | #if !defined(LUA_NBITS)
 18 | #define LUA_NBITS	32
 19 | #endif
 20 | 
 21 | 
 22 | #define ALLONES		(~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
 23 | 
 24 | /* macro to trim extra bits */
 25 | #define trim(x)		((x) & ALLONES)
 26 | 
 27 | 
 28 | /* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */
 29 | #define mask(n)		(~((ALLONES << 1) << ((n) - 1)))
 30 | 
 31 | 
 32 | typedef lua_Unsigned b_uint;
 33 | 
 34 | 
 35 | 
 36 | static b_uint andaux (lua_State *L) {
 37 |   int i, n = lua_gettop(L);
 38 |   b_uint r = ~(b_uint)0;
 39 |   for (i = 1; i <= n; i++)
 40 |     r &= luaL_checkunsigned(L, i);
 41 |   return trim(r);
 42 | }
 43 | 
 44 | 
 45 | static int b_and (lua_State *L) {
 46 |   b_uint r = andaux(L);
 47 |   lua_pushunsigned(L, r);
 48 |   return 1;
 49 | }
 50 | 
 51 | 
 52 | static int b_test (lua_State *L) {
 53 |   b_uint r = andaux(L);
 54 |   lua_pushboolean(L, r != 0);
 55 |   return 1;
 56 | }
 57 | 
 58 | 
 59 | static int b_or (lua_State *L) {
 60 |   int i, n = lua_gettop(L);
 61 |   b_uint r = 0;
 62 |   for (i = 1; i <= n; i++)
 63 |     r |= luaL_checkunsigned(L, i);
 64 |   lua_pushunsigned(L, trim(r));
 65 |   return 1;
 66 | }
 67 | 
 68 | 
 69 | static int b_xor (lua_State *L) {
 70 |   int i, n = lua_gettop(L);
 71 |   b_uint r = 0;
 72 |   for (i = 1; i <= n; i++)
 73 |     r ^= luaL_checkunsigned(L, i);
 74 |   lua_pushunsigned(L, trim(r));
 75 |   return 1;
 76 | }
 77 | 
 78 | 
 79 | static int b_not (lua_State *L) {
 80 |   b_uint r = ~luaL_checkunsigned(L, 1);
 81 |   lua_pushunsigned(L, trim(r));
 82 |   return 1;
 83 | }
 84 | 
 85 | 
 86 | static int b_shift (lua_State *L, b_uint r, int i) {
 87 |   if (i < 0) {  /* shift right? */
 88 |     i = -i;
 89 |     r = trim(r);
 90 |     if (i >= LUA_NBITS) r = 0;
 91 |     else r >>= i;
 92 |   }
 93 |   else {  /* shift left */
 94 |     if (i >= LUA_NBITS) r = 0;
 95 |     else r <<= i;
 96 |     r = trim(r);
 97 |   }
 98 |   lua_pushunsigned(L, r);
 99 |   return 1;
100 | }
101 | 
102 | 
103 | static int b_lshift (lua_State *L) {
104 |   return b_shift(L, luaL_checkunsigned(L, 1), luaL_checkint(L, 2));
105 | }
106 | 
107 | 
108 | static int b_rshift (lua_State *L) {
109 |   return b_shift(L, luaL_checkunsigned(L, 1), -luaL_checkint(L, 2));
110 | }
111 | 
112 | 
113 | static int b_arshift (lua_State *L) {
114 |   b_uint r = luaL_checkunsigned(L, 1);
115 |   int i = luaL_checkint(L, 2);
116 |   if (i < 0 || !(r & ((b_uint)1 << (LUA_NBITS - 1))))
117 |     return b_shift(L, r, -i);
118 |   else {  /* arithmetic shift for 'negative' number */
119 |     if (i >= LUA_NBITS) r = ALLONES;
120 |     else
121 |       r = trim((r >> i) | ~(~(b_uint)0 >> i));  /* add signal bit */
122 |     lua_pushunsigned(L, r);
123 |     return 1;
124 |   }
125 | }
126 | 
127 | 
128 | static int b_rot (lua_State *L, int i) {
129 |   b_uint r = luaL_checkunsigned(L, 1);
130 |   i &= (LUA_NBITS - 1);  /* i = i % NBITS */
131 |   r = trim(r);
132 |   if (i != 0)  /* avoid undefined shift of LUA_NBITS when i == 0 */
133 |     r = (r << i) | (r >> (LUA_NBITS - i));
134 |   lua_pushunsigned(L, trim(r));
135 |   return 1;
136 | }
137 | 
138 | 
139 | static int b_lrot (lua_State *L) {
140 |   return b_rot(L, luaL_checkint(L, 2));
141 | }
142 | 
143 | 
144 | static int b_rrot (lua_State *L) {
145 |   return b_rot(L, -luaL_checkint(L, 2));
146 | }
147 | 
148 | 
149 | /*
150 | ** get field and width arguments for field-manipulation functions,
151 | ** checking whether they are valid.
152 | ** ('luaL_error' called without 'return' to avoid later warnings about
153 | ** 'width' being used uninitialized.)
154 | */
155 | static int fieldargs (lua_State *L, int farg, int *width) {
156 |   int f = luaL_checkint(L, farg);
157 |   int w = luaL_optint(L, farg + 1, 1);
158 |   luaL_argcheck(L, 0 <= f, farg, "field cannot be negative");
159 |   luaL_argcheck(L, 0 < w, farg + 1, "width must be positive");
160 |   if (f + w > LUA_NBITS)
161 |     luaL_error(L, "trying to access non-existent bits");
162 |   *width = w;
163 |   return f;
164 | }
165 | 
166 | 
167 | static int b_extract (lua_State *L) {
168 |   int w;
169 |   b_uint r = luaL_checkunsigned(L, 1);
170 |   int f = fieldargs(L, 2, &w);
171 |   r = (r >> f) & mask(w);
172 |   lua_pushunsigned(L, r);
173 |   return 1;
174 | }
175 | 
176 | 
177 | static int b_replace (lua_State *L) {
178 |   int w;
179 |   b_uint r = luaL_checkunsigned(L, 1);
180 |   b_uint v = luaL_checkunsigned(L, 2);
181 |   int f = fieldargs(L, 3, &w);
182 |   int m = mask(w);
183 |   v &= m;  /* erase bits outside given width */
184 |   r = (r & ~(m << f)) | (v << f);
185 |   lua_pushunsigned(L, r);
186 |   return 1;
187 | }
188 | 
189 | 
190 | static const luaL_Reg bitlib[] = {
191 |   {"arshift", b_arshift},
192 |   {"band", b_and},
193 |   {"bnot", b_not},
194 |   {"bor", b_or},
195 |   {"bxor", b_xor},
196 |   {"btest", b_test},
197 |   {"extract", b_extract},
198 |   {"lrotate", b_lrot},
199 |   {"lshift", b_lshift},
200 |   {"replace", b_replace},
201 |   {"rrotate", b_rrot},
202 |   {"rshift", b_rshift},
203 |   {NULL, NULL}
204 | };
205 | 
206 | 
207 | 
208 | LUAMOD_API int luaopen_bit32 (lua_State *L) {
209 |   luaL_newlib(L, bitlib);
210 |   return 1;
211 | }
212 | 
213 | 


--------------------------------------------------------------------------------
/lua51/lfunc.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lfunc.c,v 2.12.1.2 2007/12/28 14:58:43 roberto Exp $
  3 | ** Auxiliary functions to manipulate prototypes and closures
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <stddef.h>
  9 | 
 10 | #define lfunc_c
 11 | #define LUA_CORE
 12 | 
 13 | #include "lua.h"
 14 | 
 15 | #include "lfunc.h"
 16 | #include "lgc.h"
 17 | #include "lmem.h"
 18 | #include "lobject.h"
 19 | #include "lstate.h"
 20 | 
 21 | 
 22 | 
 23 | Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {
 24 |   Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
 25 |   luaC_link(L, obj2gco(c), LUA_TFUNCTION);
 26 |   c->c.isC = 1;
 27 |   c->c.env = e;
 28 |   c->c.nupvalues = cast_byte(nelems);
 29 |   return c;
 30 | }
 31 | 
 32 | 
 33 | Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {
 34 |   Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
 35 |   luaC_link(L, obj2gco(c), LUA_TFUNCTION);
 36 |   c->l.isC = 0;
 37 |   c->l.env = e;
 38 |   c->l.nupvalues = cast_byte(nelems);
 39 |   while (nelems--) c->l.upvals[nelems] = NULL;
 40 |   return c;
 41 | }
 42 | 
 43 | 
 44 | UpVal *luaF_newupval (lua_State *L) {
 45 |   UpVal *uv = luaM_new(L, UpVal);
 46 |   luaC_link(L, obj2gco(uv), LUA_TUPVAL);
 47 |   uv->v = &uv->u.value;
 48 |   setnilvalue(uv->v);
 49 |   return uv;
 50 | }
 51 | 
 52 | 
 53 | UpVal *luaF_findupval (lua_State *L, StkId level) {
 54 |   global_State *g = G(L);
 55 |   GCObject **pp = &L->openupval;
 56 |   UpVal *p;
 57 |   UpVal *uv;
 58 |   while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {
 59 |     lua_assert(p->v != &p->u.value);
 60 |     if (p->v == level) {  /* found a corresponding upvalue? */
 61 |       if (isdead(g, obj2gco(p)))  /* is it dead? */
 62 |         changewhite(obj2gco(p));  /* ressurect it */
 63 |       return p;
 64 |     }
 65 |     pp = &p->next;
 66 |   }
 67 |   uv = luaM_new(L, UpVal);  /* not found: create a new one */
 68 |   uv->tt = LUA_TUPVAL;
 69 |   uv->marked = luaC_white(g);
 70 |   uv->v = level;  /* current value lives in the stack */
 71 |   uv->next = *pp;  /* chain it in the proper position */
 72 |   *pp = obj2gco(uv);
 73 |   uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
 74 |   uv->u.l.next = g->uvhead.u.l.next;
 75 |   uv->u.l.next->u.l.prev = uv;
 76 |   g->uvhead.u.l.next = uv;
 77 |   lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
 78 |   return uv;
 79 | }
 80 | 
 81 | 
 82 | static void unlinkupval (UpVal *uv) {
 83 |   lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
 84 |   uv->u.l.next->u.l.prev = uv->u.l.prev;  /* remove from `uvhead' list */
 85 |   uv->u.l.prev->u.l.next = uv->u.l.next;
 86 | }
 87 | 
 88 | 
 89 | void luaF_freeupval (lua_State *L, UpVal *uv) {
 90 |   if (uv->v != &uv->u.value)  /* is it open? */
 91 |     unlinkupval(uv);  /* remove from open list */
 92 |   luaM_free(L, uv);  /* free upvalue */
 93 | }
 94 | 
 95 | 
 96 | void luaF_close (lua_State *L, StkId level) {
 97 |   UpVal *uv;
 98 |   global_State *g = G(L);
 99 |   while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {
100 |     GCObject *o = obj2gco(uv);
101 |     lua_assert(!isblack(o) && uv->v != &uv->u.value);
102 |     L->openupval = uv->next;  /* remove from `open' list */
103 |     if (isdead(g, o))
104 |       luaF_freeupval(L, uv);  /* free upvalue */
105 |     else {
106 |       unlinkupval(uv);
107 |       setobj(L, &uv->u.value, uv->v);
108 |       uv->v = &uv->u.value;  /* now current value lives here */
109 |       luaC_linkupval(L, uv);  /* link upvalue into `gcroot' list */
110 |     }
111 |   }
112 | }
113 | 
114 | 
115 | Proto *luaF_newproto (lua_State *L) {
116 |   Proto *f = luaM_new(L, Proto);
117 |   luaC_link(L, obj2gco(f), LUA_TPROTO);
118 |   f->k = NULL;
119 |   f->sizek = 0;
120 |   f->p = NULL;
121 |   f->sizep = 0;
122 |   f->code = NULL;
123 |   f->sizecode = 0;
124 |   f->sizelineinfo = 0;
125 |   f->sizeupvalues = 0;
126 |   f->nups = 0;
127 |   f->upvalues = NULL;
128 |   f->numparams = 0;
129 |   f->is_vararg = 0;
130 |   f->maxstacksize = 0;
131 |   f->lineinfo = NULL;
132 |   f->sizelocvars = 0;
133 |   f->locvars = NULL;
134 |   f->linedefined = 0;
135 |   f->lastlinedefined = 0;
136 |   f->source = NULL;
137 |   return f;
138 | }
139 | 
140 | 
141 | void luaF_freeproto (lua_State *L, Proto *f) {
142 |   luaM_freearray(L, f->code, f->sizecode, Instruction);
143 |   luaM_freearray(L, f->p, f->sizep, Proto *);
144 |   luaM_freearray(L, f->k, f->sizek, TValue);
145 |   luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
146 |   luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
147 |   luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);
148 |   luaM_free(L, f);
149 | }
150 | 
151 | 
152 | void luaF_freeclosure (lua_State *L, Closure *c) {
153 |   int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :
154 |                           sizeLclosure(c->l.nupvalues);
155 |   luaM_freemem(L, c, size);
156 | }
157 | 
158 | 
159 | /*
160 | ** Look for n-th local variable at line `line' in function `func'.
161 | ** Returns NULL if not found.
162 | */
163 | const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
164 |   int i;
165 |   for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
166 |     if (pc < f->locvars[i].endpc) {  /* is variable active? */
167 |       local_number--;
168 |       if (local_number == 0)
169 |         return getstr(f->locvars[i].varname);
170 |     }
171 |   }
172 |   return NULL;  /* not found */
173 | }
174 | 
175 | 


--------------------------------------------------------------------------------
/lua53/ltm.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: ltm.c,v 2.38.1.1 2017/04/19 17:39:34 roberto Exp $
  3 | ** Tag methods
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #define ltm_c
  8 | #define LUA_CORE
  9 | 
 10 | #include "lprefix.h"
 11 | 
 12 | 
 13 | #include <string.h>
 14 | 
 15 | #include "lua.h"
 16 | 
 17 | #include "ldebug.h"
 18 | #include "ldo.h"
 19 | #include "lobject.h"
 20 | #include "lstate.h"
 21 | #include "lstring.h"
 22 | #include "ltable.h"
 23 | #include "ltm.h"
 24 | #include "lvm.h"
 25 | 
 26 | 
 27 | static const char udatatypename[] = "userdata";
 28 | 
 29 | LUAI_DDEF const char *const luaT_typenames_[LUA_TOTALTAGS] = {
 30 |   "no value",
 31 |   "nil", "boolean", udatatypename, "number",
 32 |   "string", "table", "function", udatatypename, "thread",
 33 |   "proto" /* this last case is used for tests only */
 34 | };
 35 | 
 36 | 
 37 | void luaT_init (lua_State *L) {
 38 |   static const char *const luaT_eventname[] = {  /* ORDER TM */
 39 |     "__index", "__newindex",
 40 |     "__gc", "__mode", "__len", "__eq",
 41 |     "__add", "__sub", "__mul", "__mod", "__pow",
 42 |     "__div", "__idiv",
 43 |     "__band", "__bor", "__bxor", "__shl", "__shr",
 44 |     "__unm", "__bnot", "__lt", "__le",
 45 |     "__concat", "__call"
 46 |   };
 47 |   int i;
 48 |   for (i=0; i<TM_N; i++) {
 49 |     G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
 50 |     luaC_fix(L, obj2gco(G(L)->tmname[i]));  /* never collect these names */
 51 |   }
 52 | }
 53 | 
 54 | 
 55 | /*
 56 | ** function to be used with macro "fasttm": optimized for absence of
 57 | ** tag methods
 58 | */
 59 | const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
 60 |   const TValue *tm = luaH_getshortstr(events, ename);
 61 |   lua_assert(event <= TM_EQ);
 62 |   if (ttisnil(tm)) {  /* no tag method? */
 63 |     events->flags |= cast_byte(1u<<event);  /* cache this fact */
 64 |     return NULL;
 65 |   }
 66 |   else return tm;
 67 | }
 68 | 
 69 | 
 70 | const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
 71 |   Table *mt;
 72 |   switch (ttnov(o)) {
 73 |     case LUA_TTABLE:
 74 |       mt = hvalue(o)->metatable;
 75 |       break;
 76 |     case LUA_TUSERDATA:
 77 |       mt = uvalue(o)->metatable;
 78 |       break;
 79 |     default:
 80 |       mt = G(L)->mt[ttnov(o)];
 81 |   }
 82 |   return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : luaO_nilobject);
 83 | }
 84 | 
 85 | 
 86 | /*
 87 | ** Return the name of the type of an object. For tables and userdata
 88 | ** with metatable, use their '__name' metafield, if present.
 89 | */
 90 | const char *luaT_objtypename (lua_State *L, const TValue *o) {
 91 |   Table *mt;
 92 |   if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) ||
 93 |       (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) {
 94 |     const TValue *name = luaH_getshortstr(mt, luaS_new(L, "__name"));
 95 |     if (ttisstring(name))  /* is '__name' a string? */
 96 |       return getstr(tsvalue(name));  /* use it as type name */
 97 |   }
 98 |   return ttypename(ttnov(o));  /* else use standard type name */
 99 | }
100 | 
101 | 
102 | void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
103 |                   const TValue *p2, TValue *p3, int hasres) {
104 |   ptrdiff_t result = savestack(L, p3);
105 |   StkId func = L->top;
106 |   setobj2s(L, func, f);  /* push function (assume EXTRA_STACK) */
107 |   setobj2s(L, func + 1, p1);  /* 1st argument */
108 |   setobj2s(L, func + 2, p2);  /* 2nd argument */
109 |   L->top += 3;
110 |   if (!hasres)  /* no result? 'p3' is third argument */
111 |     setobj2s(L, L->top++, p3);  /* 3rd argument */
112 |   /* metamethod may yield only when called from Lua code */
113 |   if (isLua(L->ci))
114 |     luaD_call(L, func, hasres);
115 |   else
116 |     luaD_callnoyield(L, func, hasres);
117 |   if (hasres) {  /* if has result, move it to its place */
118 |     p3 = restorestack(L, result);
119 |     setobjs2s(L, p3, --L->top);
120 |   }
121 | }
122 | 
123 | 
124 | int luaT_callbinTM (lua_State *L, const TValue *p1, const TValue *p2,
125 |                     StkId res, TMS event) {
126 |   const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
127 |   if (ttisnil(tm))
128 |     tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
129 |   if (ttisnil(tm)) return 0;
130 |   luaT_callTM(L, tm, p1, p2, res, 1);
131 |   return 1;
132 | }
133 | 
134 | 
135 | void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
136 |                     StkId res, TMS event) {
137 |   if (!luaT_callbinTM(L, p1, p2, res, event)) {
138 |     switch (event) {
139 |       case TM_CONCAT:
140 |         luaG_concaterror(L, p1, p2);
141 |       /* call never returns, but to avoid warnings: *//* FALLTHROUGH */
142 |       case TM_BAND: case TM_BOR: case TM_BXOR:
143 |       case TM_SHL: case TM_SHR: case TM_BNOT: {
144 |         lua_Number dummy;
145 |         if (tonumber(p1, &dummy) && tonumber(p2, &dummy))
146 |           luaG_tointerror(L, p1, p2);
147 |         else
148 |           luaG_opinterror(L, p1, p2, "perform bitwise operation on");
149 |       }
150 |       /* calls never return, but to avoid warnings: *//* FALLTHROUGH */
151 |       default:
152 |         luaG_opinterror(L, p1, p2, "perform arithmetic on");
153 |     }
154 |   }
155 | }
156 | 
157 | 
158 | int luaT_callorderTM (lua_State *L, const TValue *p1, const TValue *p2,
159 |                       TMS event) {
160 |   if (!luaT_callbinTM(L, p1, p2, L->top, event))
161 |     return -1;  /* no metamethod */
162 |   else
163 |     return !l_isfalse(L->top);
164 | }
165 | 
166 | 


--------------------------------------------------------------------------------
/lua53/ldump.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: ldump.c,v 2.37.1.1 2017/04/19 17:20:42 roberto Exp $
  3 | ** save precompiled Lua chunks
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #define ldump_c
  8 | #define LUA_CORE
  9 | 
 10 | #include "lprefix.h"
 11 | 
 12 | 
 13 | #include <stddef.h>
 14 | 
 15 | #include "lua.h"
 16 | 
 17 | #include "lobject.h"
 18 | #include "lstate.h"
 19 | #include "lundump.h"
 20 | 
 21 | 
 22 | typedef struct {
 23 |   lua_State *L;
 24 |   lua_Writer writer;
 25 |   void *data;
 26 |   int strip;
 27 |   int status;
 28 | } DumpState;
 29 | 
 30 | 
 31 | /*
 32 | ** All high-level dumps go through DumpVector; you can change it to
 33 | ** change the endianness of the result
 34 | */
 35 | #define DumpVector(v,n,D)	DumpBlock(v,(n)*sizeof((v)[0]),D)
 36 | 
 37 | #define DumpLiteral(s,D)	DumpBlock(s, sizeof(s) - sizeof(char), D)
 38 | 
 39 | 
 40 | static void DumpBlock (const void *b, size_t size, DumpState *D) {
 41 |   if (D->status == 0 && size > 0) {
 42 |     lua_unlock(D->L);
 43 |     D->status = (*D->writer)(D->L, b, size, D->data);
 44 |     lua_lock(D->L);
 45 |   }
 46 | }
 47 | 
 48 | 
 49 | #define DumpVar(x,D)		DumpVector(&x,1,D)
 50 | 
 51 | 
 52 | static void DumpByte (int y, DumpState *D) {
 53 |   lu_byte x = (lu_byte)y;
 54 |   DumpVar(x, D);
 55 | }
 56 | 
 57 | 
 58 | static void DumpInt (int x, DumpState *D) {
 59 |   DumpVar(x, D);
 60 | }
 61 | 
 62 | 
 63 | static void DumpNumber (lua_Number x, DumpState *D) {
 64 |   DumpVar(x, D);
 65 | }
 66 | 
 67 | 
 68 | static void DumpInteger (lua_Integer x, DumpState *D) {
 69 |   DumpVar(x, D);
 70 | }
 71 | 
 72 | 
 73 | static void DumpString (const TString *s, DumpState *D) {
 74 |   if (s == NULL)
 75 |     DumpByte(0, D);
 76 |   else {
 77 |     size_t size = tsslen(s) + 1;  /* include trailing '\0' */
 78 |     const char *str = getstr(s);
 79 |     if (size < 0xFF)
 80 |       DumpByte(cast_int(size), D);
 81 |     else {
 82 |       DumpByte(0xFF, D);
 83 |       DumpVar(size, D);
 84 |     }
 85 |     DumpVector(str, size - 1, D);  /* no need to save '\0' */
 86 |   }
 87 | }
 88 | 
 89 | 
 90 | static void DumpCode (const Proto *f, DumpState *D) {
 91 |   DumpInt(f->sizecode, D);
 92 |   DumpVector(f->code, f->sizecode, D);
 93 | }
 94 | 
 95 | 
 96 | static void DumpFunction(const Proto *f, TString *psource, DumpState *D);
 97 | 
 98 | static void DumpConstants (const Proto *f, DumpState *D) {
 99 |   int i;
100 |   int n = f->sizek;
101 |   DumpInt(n, D);
102 |   for (i = 0; i < n; i++) {
103 |     const TValue *o = &f->k[i];
104 |     DumpByte(ttype(o), D);
105 |     switch (ttype(o)) {
106 |     case LUA_TNIL:
107 |       break;
108 |     case LUA_TBOOLEAN:
109 |       DumpByte(bvalue(o), D);
110 |       break;
111 |     case LUA_TNUMFLT:
112 |       DumpNumber(fltvalue(o), D);
113 |       break;
114 |     case LUA_TNUMINT:
115 |       DumpInteger(ivalue(o), D);
116 |       break;
117 |     case LUA_TSHRSTR:
118 |     case LUA_TLNGSTR:
119 |       DumpString(tsvalue(o), D);
120 |       break;
121 |     default:
122 |       lua_assert(0);
123 |     }
124 |   }
125 | }
126 | 
127 | 
128 | static void DumpProtos (const Proto *f, DumpState *D) {
129 |   int i;
130 |   int n = f->sizep;
131 |   DumpInt(n, D);
132 |   for (i = 0; i < n; i++)
133 |     DumpFunction(f->p[i], f->source, D);
134 | }
135 | 
136 | 
137 | static void DumpUpvalues (const Proto *f, DumpState *D) {
138 |   int i, n = f->sizeupvalues;
139 |   DumpInt(n, D);
140 |   for (i = 0; i < n; i++) {
141 |     DumpByte(f->upvalues[i].instack, D);
142 |     DumpByte(f->upvalues[i].idx, D);
143 |   }
144 | }
145 | 
146 | 
147 | static void DumpDebug (const Proto *f, DumpState *D) {
148 |   int i, n;
149 |   n = (D->strip) ? 0 : f->sizelineinfo;
150 |   DumpInt(n, D);
151 |   DumpVector(f->lineinfo, n, D);
152 |   n = (D->strip) ? 0 : f->sizelocvars;
153 |   DumpInt(n, D);
154 |   for (i = 0; i < n; i++) {
155 |     DumpString(f->locvars[i].varname, D);
156 |     DumpInt(f->locvars[i].startpc, D);
157 |     DumpInt(f->locvars[i].endpc, D);
158 |   }
159 |   n = (D->strip) ? 0 : f->sizeupvalues;
160 |   DumpInt(n, D);
161 |   for (i = 0; i < n; i++)
162 |     DumpString(f->upvalues[i].name, D);
163 | }
164 | 
165 | 
166 | static void DumpFunction (const Proto *f, TString *psource, DumpState *D) {
167 |   if (D->strip || f->source == psource)
168 |     DumpString(NULL, D);  /* no debug info or same source as its parent */
169 |   else
170 |     DumpString(f->source, D);
171 |   DumpInt(f->linedefined, D);
172 |   DumpInt(f->lastlinedefined, D);
173 |   DumpByte(f->numparams, D);
174 |   DumpByte(f->is_vararg, D);
175 |   DumpByte(f->maxstacksize, D);
176 |   DumpCode(f, D);
177 |   DumpConstants(f, D);
178 |   DumpUpvalues(f, D);
179 |   DumpProtos(f, D);
180 |   DumpDebug(f, D);
181 | }
182 | 
183 | 
184 | static void DumpHeader (DumpState *D) {
185 |   DumpLiteral(LUA_SIGNATURE, D);
186 |   DumpByte(LUAC_VERSION, D);
187 |   DumpByte(LUAC_FORMAT, D);
188 |   DumpLiteral(LUAC_DATA, D);
189 |   DumpByte(sizeof(int), D);
190 |   DumpByte(sizeof(size_t), D);
191 |   DumpByte(sizeof(Instruction), D);
192 |   DumpByte(sizeof(lua_Integer), D);
193 |   DumpByte(sizeof(lua_Number), D);
194 |   DumpInteger(LUAC_INT, D);
195 |   DumpNumber(LUAC_NUM, D);
196 | }
197 | 
198 | 
199 | /*
200 | ** dump Lua function as precompiled chunk
201 | */
202 | int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data,
203 |               int strip) {
204 |   DumpState D;
205 |   D.L = L;
206 |   D.writer = w;
207 |   D.data = data;
208 |   D.strip = strip;
209 |   D.status = 0;
210 |   DumpHeader(&D);
211 |   DumpByte(f->sizeupvalues, &D);
212 |   DumpFunction(f, NULL, &D);
213 |   return D.status;
214 | }
215 | 
216 | 


--------------------------------------------------------------------------------
/lua51/luac.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: luac.c,v 1.54 2006/06/02 17:37:11 lhf Exp $
  3 | ** Lua compiler (saves bytecodes to files; also list bytecodes)
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #include <errno.h>
  8 | #include <stdio.h>
  9 | #include <stdlib.h>
 10 | #include <string.h>
 11 | 
 12 | #define luac_c
 13 | #define LUA_CORE
 14 | 
 15 | #include "lua.h"
 16 | #include "lauxlib.h"
 17 | 
 18 | #include "ldo.h"
 19 | #include "lfunc.h"
 20 | #include "lmem.h"
 21 | #include "lobject.h"
 22 | #include "lopcodes.h"
 23 | #include "lstring.h"
 24 | #include "lundump.h"
 25 | #include "lclib.h"
 26 | 
 27 | #define PROGNAME	"luac"		/* default program name */
 28 | #define	OUTPUT		PROGNAME ".out"	/* default output file */
 29 | 
 30 | static int listing=0;			/* list bytecodes? */
 31 | static int dumping=1;			/* dump bytecodes? */
 32 | static int stripping=0;			/* strip debug information? */
 33 | static char Output[]={ OUTPUT };	/* default output file name */
 34 | static const char* output=Output;	/* actual output file name */
 35 | static const char* progname=PROGNAME;	/* actual program name */
 36 | 
 37 | static void fatal(const char* message)
 38 | {
 39 |  fprintf(stderr,"%s: %s\n",progname,message);
 40 |  exit(EXIT_FAILURE);
 41 | }
 42 | 
 43 | static void cannot(const char* what)
 44 | {
 45 |  fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
 46 |  exit(EXIT_FAILURE);
 47 | }
 48 | 
 49 | static void usage(const char* message)
 50 | {
 51 |  if (*message=='-')
 52 |   fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
 53 |  else
 54 |   fprintf(stderr,"%s: %s\n",progname,message);
 55 |  fprintf(stderr,
 56 |  "usage: %s [options] [filenames].\n"
 57 |  "Available options are:\n"
 58 |  "  -        process stdin\n"
 59 |  "  -l       list\n"
 60 |  "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
 61 |  "  -p       parse only\n"
 62 |  "  -s       strip debug information\n"
 63 |  "  -v       show version information\n"
 64 |  "  --       stop handling options\n",
 65 |  progname,Output);
 66 |  exit(EXIT_FAILURE);
 67 | }
 68 | 
 69 | #define	IS(s)	(strcmp(argv[i],s)==0)
 70 | 
 71 | static int doargs(int argc, char* argv[])
 72 | {
 73 |  int i;
 74 |  int version=0;
 75 |  if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];
 76 |  for (i=1; i<argc; i++)
 77 |  {
 78 |   if (*argv[i]!='-')			/* end of options; keep it */
 79 |    break;
 80 |   else if (IS("--"))			/* end of options; skip it */
 81 |   {
 82 |    ++i;
 83 |    if (version) ++version;
 84 |    break;
 85 |   }
 86 |   else if (IS("-"))			/* end of options; use stdin */
 87 |    break;
 88 |   else if (IS("-l"))			/* list */
 89 |    ++listing;
 90 |   else if (IS("-o"))			/* output file */
 91 |   {
 92 |    output=argv[++i];
 93 |    if (output==NULL || *output==0) usage(LUA_QL("-o") " needs argument");
 94 |    if (IS("-")) output=NULL;
 95 |   }
 96 |   else if (IS("-p"))			/* parse only */
 97 |    dumping=0;
 98 |   else if (IS("-s"))			/* strip debug information */
 99 |    stripping=1;
100 |   else if (IS("-v"))			/* show version */
101 |    ++version;
102 |   else					/* unknown option */
103 |    usage(argv[i]);
104 |  }
105 |  if (i==argc && (listing || !dumping))
106 |  {
107 |   dumping=0;
108 |   argv[--i]=Output;
109 |  }
110 |  if (version)
111 |  {
112 |   printf("%s  %s\n",LUA_RELEASE,LUA_COPYRIGHT);
113 |   if (version==argc-1) exit(EXIT_SUCCESS);
114 |  }
115 |  return i;
116 | }
117 | 
118 | #define toproto(L,i) (clvalue(L->top+(i))->l.p)
119 | 
120 | static const Proto* combine(lua_State* L, int n)
121 | {
122 |  if (n==1)
123 |   return toproto(L,-1);
124 |  else
125 |  {
126 |   int i,pc;
127 |   Proto* f=luaF_newproto(L);
128 |   setptvalue2s(L,L->top,f); incr_top(L);
129 |   f->source=luaS_newliteral(L,"=(" PROGNAME ")");
130 |   f->maxstacksize=1;
131 |   pc=2*n+1;
132 |   f->code=luaM_newvector(L,pc,Instruction);
133 |   f->sizecode=pc;
134 |   f->p=luaM_newvector(L,n,Proto*);
135 |   f->sizep=n;
136 |   pc=0;
137 |   for (i=0; i<n; i++)
138 |   {
139 |    f->p[i]=toproto(L,i-n-1);
140 |    f->code[pc++]=CREATE_ABx(OP_CLOSURE,0,i);
141 |    f->code[pc++]=CREATE_ABC(OP_CALL,0,1,1);
142 |   }
143 |   f->code[pc++]=CREATE_ABC(OP_RETURN,0,1,0);
144 |   return f;
145 |  }
146 | }
147 | 
148 | static int writer(lua_State* L, const void* p, size_t size, void* u)
149 | {
150 |  UNUSED(L);
151 |  return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
152 | }
153 | 
154 | struct Smain {
155 |  int argc;
156 |  char** argv;
157 | };
158 | 
159 | static int pmain(lua_State* L)
160 | {
161 |  struct Smain* s = (struct Smain*)lua_touserdata(L, 1);
162 |  int argc=s->argc;
163 |  char** argv=s->argv;
164 |  const Proto* f;
165 |  int i;
166 |  if (!lua_checkstack(L,argc)) fatal("too many input files");
167 |  for (i=0; i<argc; i++)
168 |  {
169 |   const char* filename=IS("-") ? NULL : argv[i];
170 |   if (luaC_loadfile(L,filename)!=0) fatal(lua_tostring(L,-1));
171 |  }
172 |  f=combine(L,argc);
173 |  if (listing) luaU_print(f,listing>1);
174 |  if (dumping)
175 |  {
176 |   FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
177 |   if (D==NULL) cannot("open");
178 |   lua_lock(L);
179 |   luaU_dump(L,f,writer,D,stripping);
180 |   lua_unlock(L);
181 |   if (ferror(D)) cannot("write");
182 |   if (fclose(D)) cannot("close");
183 |  }
184 |  return 0;
185 | }
186 | 
187 | int main(int argc, char* argv[])
188 | {
189 |  lua_State* L;
190 |  struct Smain s;
191 |  int i=doargs(argc,argv);
192 |  argc-=i; argv+=i;
193 |  if (argc<=0) usage("no input files given");
194 |  L=lua_open();
195 |  if (L==NULL) fatal("not enough memory for state");
196 |  s.argc=argc;
197 |  s.argv=argv;
198 |  if (lua_cpcall(L,pmain,&s)!=0) fatal(lua_tostring(L,-1));
199 |  lua_close(L);
200 |  return EXIT_SUCCESS;
201 | }
202 | 


--------------------------------------------------------------------------------
/lua51/lundump.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lundump.c,v 2.7.1.4 2008/04/04 19:51:41 roberto Exp $
  3 | ** load precompiled Lua chunks
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #include <string.h>
  8 | 
  9 | #define lundump_c
 10 | #define LUA_CORE
 11 | 
 12 | #include "lua.h"
 13 | 
 14 | #include "ldebug.h"
 15 | #include "ldo.h"
 16 | #include "lfunc.h"
 17 | #include "lmem.h"
 18 | #include "lobject.h"
 19 | #include "lstring.h"
 20 | #include "lundump.h"
 21 | #include "lzio.h"
 22 | 
 23 | typedef struct {
 24 |  lua_State* L;
 25 |  ZIO* Z;
 26 |  Mbuffer* b;
 27 |  const char* name;
 28 | } LoadState;
 29 | 
 30 | #ifdef LUAC_TRUST_BINARIES
 31 | #define IF(c,s)
 32 | #define error(S,s)
 33 | #else
 34 | #define IF(c,s)		if (c) error(S,s)
 35 | 
 36 | static void error(LoadState* S, const char* why)
 37 | {
 38 |  luaO_pushfstring(S->L,"%s: %s in precompiled chunk",S->name,why);
 39 |  luaD_throw(S->L,LUA_ERRSYNTAX);
 40 | }
 41 | #endif
 42 | 
 43 | #define LoadMem(S,b,n,size)	LoadBlock(S,b,(n)*(size))
 44 | #define	LoadByte(S)		(lu_byte)LoadChar(S)
 45 | #define LoadVar(S,x)		LoadMem(S,&x,1,sizeof(x))
 46 | #define LoadVector(S,b,n,size)	LoadMem(S,b,n,size)
 47 | 
 48 | static void LoadBlock(LoadState* S, void* b, size_t size)
 49 | {
 50 |  size_t r=luaZ_read(S->Z,b,size);
 51 |  IF (r!=0, "unexpected end");
 52 | }
 53 | 
 54 | static int LoadChar(LoadState* S)
 55 | {
 56 |  char x;
 57 |  LoadVar(S,x);
 58 |  return x;
 59 | }
 60 | 
 61 | static int LoadInt(LoadState* S)
 62 | {
 63 |  int x;
 64 |  LoadVar(S,x);
 65 |  IF (x<0, "bad integer");
 66 |  return x;
 67 | }
 68 | 
 69 | static lua_Number LoadNumber(LoadState* S)
 70 | {
 71 |  lua_Number x;
 72 |  LoadVar(S,x);
 73 |  return x;
 74 | }
 75 | 
 76 | static TString* LoadString(LoadState* S)
 77 | {
 78 |  size_t size;
 79 |  LoadVar(S,size);
 80 |  if (size==0)
 81 |   return NULL;
 82 |  else
 83 |  {
 84 |   char* s=luaZ_openspace(S->L,S->b,size);
 85 |   LoadBlock(S,s,size);
 86 |   return luaS_newlstr(S->L,s,size-1);		/* remove trailing '\0' */
 87 |  }
 88 | }
 89 | 
 90 | static void LoadCode(LoadState* S, Proto* f)
 91 | {
 92 |  int n=LoadInt(S);
 93 |  f->code=luaM_newvector(S->L,n,Instruction);
 94 |  f->sizecode=n;
 95 |  LoadVector(S,f->code,n,sizeof(Instruction));
 96 | }
 97 | 
 98 | static Proto* LoadFunction(LoadState* S, TString* p);
 99 | 
100 | static void LoadConstants(LoadState* S, Proto* f)
101 | {
102 |  int i,n;
103 |  n=LoadInt(S);
104 |  f->k=luaM_newvector(S->L,n,TValue);
105 |  f->sizek=n;
106 |  for (i=0; i<n; i++) setnilvalue(&f->k[i]);
107 |  for (i=0; i<n; i++)
108 |  {
109 |   TValue* o=&f->k[i];
110 |   int t=LoadChar(S);
111 |   switch (t)
112 |   {
113 |    case LUA_TNIL:
114 |    	setnilvalue(o);
115 | 	break;
116 |    case LUA_TBOOLEAN:
117 |    	setbvalue(o,LoadChar(S)!=0);
118 | 	break;
119 |    case LUA_TNUMBER:
120 | 	setnvalue(o,LoadNumber(S));
121 | 	break;
122 |    case LUA_TSTRING:
123 | 	setsvalue2n(S->L,o,LoadString(S));
124 | 	break;
125 |    default:
126 | 	error(S,"bad constant");
127 | 	break;
128 |   }
129 |  }
130 |  n=LoadInt(S);
131 |  f->p=luaM_newvector(S->L,n,Proto*);
132 |  f->sizep=n;
133 |  for (i=0; i<n; i++) f->p[i]=NULL;
134 |  for (i=0; i<n; i++) f->p[i]=LoadFunction(S,f->source);
135 | }
136 | 
137 | static void LoadDebug(LoadState* S, Proto* f)
138 | {
139 |  int i,n;
140 |  n=LoadInt(S);
141 |  f->lineinfo=luaM_newvector(S->L,n,int);
142 |  f->sizelineinfo=n;
143 |  LoadVector(S,f->lineinfo,n,sizeof(int));
144 |  n=LoadInt(S);
145 |  f->locvars=luaM_newvector(S->L,n,LocVar);
146 |  f->sizelocvars=n;
147 |  for (i=0; i<n; i++) f->locvars[i].varname=NULL;
148 |  for (i=0; i<n; i++)
149 |  {
150 |   f->locvars[i].varname=LoadString(S);
151 |   f->locvars[i].startpc=LoadInt(S);
152 |   f->locvars[i].endpc=LoadInt(S);
153 |  }
154 |  n=LoadInt(S);
155 |  f->upvalues=luaM_newvector(S->L,n,TString*);
156 |  f->sizeupvalues=n;
157 |  for (i=0; i<n; i++) f->upvalues[i]=NULL;
158 |  for (i=0; i<n; i++) f->upvalues[i]=LoadString(S);
159 | }
160 | 
161 | static Proto* LoadFunction(LoadState* S, TString* p)
162 | {
163 |  Proto* f;
164 |  if (++S->L->nCcalls > LUAI_MAXCCALLS) error(S,"code too deep");
165 |  f=luaF_newproto(S->L);
166 |  setptvalue2s(S->L,S->L->top,f); incr_top(S->L);
167 |  f->source=LoadString(S); if (f->source==NULL) f->source=p;
168 |  f->linedefined=LoadInt(S);
169 |  f->lastlinedefined=LoadInt(S);
170 |  f->nups=LoadByte(S);
171 |  f->numparams=LoadByte(S);
172 |  f->is_vararg=LoadByte(S);
173 |  f->maxstacksize=LoadByte(S);
174 |  LoadCode(S,f);
175 |  LoadConstants(S,f);
176 |  LoadDebug(S,f);
177 |  IF (!luaG_checkcode(f), "bad code");
178 |  S->L->top--;
179 |  S->L->nCcalls--;
180 |  return f;
181 | }
182 | 
183 | static void LoadHeader(LoadState* S)
184 | {
185 |  char h[LUAC_HEADERSIZE];
186 |  char s[LUAC_HEADERSIZE];
187 |  luaU_header(h);
188 |  LoadBlock(S,s,LUAC_HEADERSIZE);
189 |  IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
190 | }
191 | 
192 | /*
193 | ** load precompiled chunk
194 | */
195 | Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
196 | {
197 |  LoadState S;
198 |  if (*name=='@' || *name=='=')
199 |   S.name=name+1;
200 |  else if (*name==LUA_SIGNATURE[0])
201 |   S.name="binary string";
202 |  else
203 |   S.name=name;
204 |  S.L=L;
205 |  S.Z=Z;
206 |  S.b=buff;
207 |  LoadHeader(&S);
208 |  return LoadFunction(&S,luaS_newliteral(L,"=?"));
209 | }
210 | 
211 | /*
212 | * make header
213 | */
214 | void luaU_header (char* h)
215 | {
216 |  int x=1;
217 |  memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1);
218 |  h+=sizeof(LUA_SIGNATURE)-1;
219 |  *h++=(char)LUAC_VERSION;
220 |  *h++=(char)LUAC_FORMAT;
221 |  *h++=(char)*(char*)&x;				/* endianness */
222 |  *h++=(char)sizeof(int);
223 |  *h++=(char)sizeof(size_t);
224 |  *h++=(char)sizeof(Instruction);
225 |  *h++=(char)sizeof(lua_Number);
226 |  *h++=(char)(((lua_Number)0.5)==0);		/* is lua_Number integral? */
227 | }
228 | 


--------------------------------------------------------------------------------
/lua52/lstring.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lstring.c,v 2.26.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** String table (keeps all strings handled by Lua)
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <string.h>
  9 | 
 10 | #define lstring_c
 11 | #define LUA_CORE
 12 | 
 13 | #include "lua.h"
 14 | 
 15 | #include "lmem.h"
 16 | #include "lobject.h"
 17 | #include "lstate.h"
 18 | #include "lstring.h"
 19 | 
 20 | 
 21 | /*
 22 | ** Lua will use at most ~(2^LUAI_HASHLIMIT) bytes from a string to
 23 | ** compute its hash
 24 | */
 25 | #if !defined(LUAI_HASHLIMIT)
 26 | #define LUAI_HASHLIMIT		5
 27 | #endif
 28 | 
 29 | 
 30 | /*
 31 | ** equality for long strings
 32 | */
 33 | int luaS_eqlngstr (TString *a, TString *b) {
 34 |   size_t len = a->tsv.len;
 35 |   lua_assert(a->tsv.tt == LUA_TLNGSTR && b->tsv.tt == LUA_TLNGSTR);
 36 |   return (a == b) ||  /* same instance or... */
 37 |     ((len == b->tsv.len) &&  /* equal length and ... */
 38 |      (memcmp(getstr(a), getstr(b), len) == 0));  /* equal contents */
 39 | }
 40 | 
 41 | 
 42 | /*
 43 | ** equality for strings
 44 | */
 45 | int luaS_eqstr (TString *a, TString *b) {
 46 |   return (a->tsv.tt == b->tsv.tt) &&
 47 |          (a->tsv.tt == LUA_TSHRSTR ? eqshrstr(a, b) : luaS_eqlngstr(a, b));
 48 | }
 49 | 
 50 | 
 51 | unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
 52 |   unsigned int h = seed ^ cast(unsigned int, l);
 53 |   size_t l1;
 54 |   size_t step = (l >> LUAI_HASHLIMIT) + 1;
 55 |   for (l1 = l; l1 >= step; l1 -= step)
 56 |     h = h ^ ((h<<5) + (h>>2) + cast_byte(str[l1 - 1]));
 57 |   return h;
 58 | }
 59 | 
 60 | 
 61 | /*
 62 | ** resizes the string table
 63 | */
 64 | void luaS_resize (lua_State *L, int newsize) {
 65 |   int i;
 66 |   stringtable *tb = &G(L)->strt;
 67 |   /* cannot resize while GC is traversing strings */
 68 |   luaC_runtilstate(L, ~bitmask(GCSsweepstring));
 69 |   if (newsize > tb->size) {
 70 |     luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *);
 71 |     for (i = tb->size; i < newsize; i++) tb->hash[i] = NULL;
 72 |   }
 73 |   /* rehash */
 74 |   for (i=0; i<tb->size; i++) {
 75 |     GCObject *p = tb->hash[i];
 76 |     tb->hash[i] = NULL;
 77 |     while (p) {  /* for each node in the list */
 78 |       GCObject *next = gch(p)->next;  /* save next */
 79 |       unsigned int h = lmod(gco2ts(p)->hash, newsize);  /* new position */
 80 |       gch(p)->next = tb->hash[h];  /* chain it */
 81 |       tb->hash[h] = p;
 82 |       resetoldbit(p);  /* see MOVE OLD rule */
 83 |       p = next;
 84 |     }
 85 |   }
 86 |   if (newsize < tb->size) {
 87 |     /* shrinking slice must be empty */
 88 |     lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL);
 89 |     luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *);
 90 |   }
 91 |   tb->size = newsize;
 92 | }
 93 | 
 94 | 
 95 | /*
 96 | ** creates a new string object
 97 | */
 98 | static TString *createstrobj (lua_State *L, const char *str, size_t l,
 99 |                               int tag, unsigned int h, GCObject **list) {
100 |   TString *ts;
101 |   size_t totalsize;  /* total size of TString object */
102 |   totalsize = sizeof(TString) + ((l + 1) * sizeof(char));
103 |   ts = &luaC_newobj(L, tag, totalsize, list, 0)->ts;
104 |   ts->tsv.len = l;
105 |   ts->tsv.hash = h;
106 |   ts->tsv.extra = 0;
107 |   memcpy(ts+1, str, l*sizeof(char));
108 |   ((char *)(ts+1))[l] = '\0';  /* ending 0 */
109 |   return ts;
110 | }
111 | 
112 | 
113 | /*
114 | ** creates a new short string, inserting it into string table
115 | */
116 | static TString *newshrstr (lua_State *L, const char *str, size_t l,
117 |                                        unsigned int h) {
118 |   GCObject **list;  /* (pointer to) list where it will be inserted */
119 |   stringtable *tb = &G(L)->strt;
120 |   TString *s;
121 |   if (tb->nuse >= cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
122 |     luaS_resize(L, tb->size*2);  /* too crowded */
123 |   list = &tb->hash[lmod(h, tb->size)];
124 |   s = createstrobj(L, str, l, LUA_TSHRSTR, h, list);
125 |   tb->nuse++;
126 |   return s;
127 | }
128 | 
129 | 
130 | /*
131 | ** checks whether short string exists and reuses it or creates a new one
132 | */
133 | static TString *internshrstr (lua_State *L, const char *str, size_t l) {
134 |   GCObject *o;
135 |   global_State *g = G(L);
136 |   unsigned int h = luaS_hash(str, l, g->seed);
137 |   for (o = g->strt.hash[lmod(h, g->strt.size)];
138 |        o != NULL;
139 |        o = gch(o)->next) {
140 |     TString *ts = rawgco2ts(o);
141 |     if (h == ts->tsv.hash &&
142 |         l == ts->tsv.len &&
143 |         (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
144 |       if (isdead(G(L), o))  /* string is dead (but was not collected yet)? */
145 |         changewhite(o);  /* resurrect it */
146 |       return ts;
147 |     }
148 |   }
149 |   return newshrstr(L, str, l, h);  /* not found; create a new string */
150 | }
151 | 
152 | 
153 | /*
154 | ** new string (with explicit length)
155 | */
156 | TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
157 |   if (l <= LUAI_MAXSHORTLEN)  /* short string? */
158 |     return internshrstr(L, str, l);
159 |   else {
160 |     if (l + 1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
161 |       luaM_toobig(L);
162 |     return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed, NULL);
163 |   }
164 | }
165 | 
166 | 
167 | /*
168 | ** new zero-terminated string
169 | */
170 | TString *luaS_new (lua_State *L, const char *str) {
171 |   return luaS_newlstr(L, str, strlen(str));
172 | }
173 | 
174 | 
175 | Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
176 |   Udata *u;
177 |   if (s > MAX_SIZET - sizeof(Udata))
178 |     luaM_toobig(L);
179 |   u = &luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s, NULL, 0)->u;
180 |   u->uv.len = s;
181 |   u->uv.metatable = NULL;
182 |   u->uv.env = e;
183 |   return u;
184 | }
185 | 
186 | 


--------------------------------------------------------------------------------