aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/LuaJIT-1.1.7/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--libraries/LuaJIT-1.1.7/src/Makefile252
-rw-r--r--libraries/LuaJIT-1.1.7/src/lapi.c1082
-rw-r--r--libraries/LuaJIT-1.1.7/src/lapi.h16
-rw-r--r--libraries/LuaJIT-1.1.7/src/lauxlib.c652
-rw-r--r--libraries/LuaJIT-1.1.7/src/lauxlib.h174
-rw-r--r--libraries/LuaJIT-1.1.7/src/lbaselib.c679
-rw-r--r--libraries/LuaJIT-1.1.7/src/lcoco.c693
-rw-r--r--libraries/LuaJIT-1.1.7/src/lcoco.h72
-rw-r--r--libraries/LuaJIT-1.1.7/src/lcode.c831
-rw-r--r--libraries/LuaJIT-1.1.7/src/lcode.h76
-rw-r--r--libraries/LuaJIT-1.1.7/src/ldblib.c398
-rw-r--r--libraries/LuaJIT-1.1.7/src/ldebug.c640
-rw-r--r--libraries/LuaJIT-1.1.7/src/ldebug.h33
-rw-r--r--libraries/LuaJIT-1.1.7/src/ldo.c519
-rw-r--r--libraries/LuaJIT-1.1.7/src/ldo.h59
-rw-r--r--libraries/LuaJIT-1.1.7/src/ldump.c164
-rw-r--r--libraries/LuaJIT-1.1.7/src/lfunc.c182
-rw-r--r--libraries/LuaJIT-1.1.7/src/lfunc.h34
-rw-r--r--libraries/LuaJIT-1.1.7/src/lgc.c711
-rw-r--r--libraries/LuaJIT-1.1.7/src/lgc.h110
-rw-r--r--libraries/LuaJIT-1.1.7/src/linit.c39
-rw-r--r--libraries/LuaJIT-1.1.7/src/liolib.c556
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljit.h167
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljit_backend.c342
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljit_core.c385
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljit_dasm.c38
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljit_dasm.h19
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljit_hints.h137
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljit_mem.c405
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljit_x86.dasc2457
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljit_x86.dash297
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljit_x86.h2301
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljit_x86_inline.dash625
-rw-r--r--libraries/LuaJIT-1.1.7/src/ljitlib.c637
-rw-r--r--libraries/LuaJIT-1.1.7/src/llex.c463
-rw-r--r--libraries/LuaJIT-1.1.7/src/llex.h81
-rw-r--r--libraries/LuaJIT-1.1.7/src/llimits.h128
-rw-r--r--libraries/LuaJIT-1.1.7/src/lmathlib.c263
-rw-r--r--libraries/LuaJIT-1.1.7/src/lmem.c86
-rw-r--r--libraries/LuaJIT-1.1.7/src/lmem.h49
-rw-r--r--libraries/LuaJIT-1.1.7/src/loadlib.c669
-rw-r--r--libraries/LuaJIT-1.1.7/src/lobject.c214
-rw-r--r--libraries/LuaJIT-1.1.7/src/lobject.h386
-rw-r--r--libraries/LuaJIT-1.1.7/src/lopcodes.c102
-rw-r--r--libraries/LuaJIT-1.1.7/src/lopcodes.h268
-rw-r--r--libraries/LuaJIT-1.1.7/src/loslib.c244
-rw-r--r--libraries/LuaJIT-1.1.7/src/lparser.c1339
-rw-r--r--libraries/LuaJIT-1.1.7/src/lparser.h82
-rw-r--r--libraries/LuaJIT-1.1.7/src/lstate.c218
-rw-r--r--libraries/LuaJIT-1.1.7/src/lstate.h179
-rw-r--r--libraries/LuaJIT-1.1.7/src/lstring.c111
-rw-r--r--libraries/LuaJIT-1.1.7/src/lstring.h31
-rw-r--r--libraries/LuaJIT-1.1.7/src/lstrlib.c871
-rw-r--r--libraries/LuaJIT-1.1.7/src/ltable.c588
-rw-r--r--libraries/LuaJIT-1.1.7/src/ltable.h41
-rw-r--r--libraries/LuaJIT-1.1.7/src/ltablib.c287
-rw-r--r--libraries/LuaJIT-1.1.7/src/ltm.c75
-rw-r--r--libraries/LuaJIT-1.1.7/src/ltm.h54
-rw-r--r--libraries/LuaJIT-1.1.7/src/lua.c463
-rw-r--r--libraries/LuaJIT-1.1.7/src/lua.h385
-rw-r--r--libraries/LuaJIT-1.1.7/src/luac.c200
-rw-r--r--libraries/LuaJIT-1.1.7/src/luaconf.h786
-rw-r--r--libraries/LuaJIT-1.1.7/src/luajit.h68
-rw-r--r--libraries/LuaJIT-1.1.7/src/lualib.h56
-rw-r--r--libraries/LuaJIT-1.1.7/src/lundump.c227
-rw-r--r--libraries/LuaJIT-1.1.7/src/lundump.h36
-rw-r--r--libraries/LuaJIT-1.1.7/src/lvm.c766
-rw-r--r--libraries/LuaJIT-1.1.7/src/lvm.h40
-rw-r--r--libraries/LuaJIT-1.1.7/src/lzio.c82
-rw-r--r--libraries/LuaJIT-1.1.7/src/lzio.h67
-rw-r--r--libraries/LuaJIT-1.1.7/src/print.c227
71 files changed, 26014 insertions, 0 deletions
diff --git a/libraries/LuaJIT-1.1.7/src/Makefile b/libraries/LuaJIT-1.1.7/src/Makefile
new file mode 100644
index 0000000..b678fe1
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/Makefile
@@ -0,0 +1,252 @@
1# makefile for building Lua
2# see ../INSTALL for installation instructions
3# see ../Makefile and luaconf.h for further customization
4
5# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
6
7# Your platform. See PLATS for possible values.
8PLAT= none
9
10CC= gcc -m32
11CFLAGS= -O2 -fomit-frame-pointer -Wall $(MYCFLAGS) $(COCOCFLAGS) $(JITCFLAGS)
12AR= ar rcu
13RANLIB= ranlib
14RM= rm -f
15LIBS= -lm $(MYLIBS)
16
17MYCFLAGS=
18MYLDFLAGS=
19MYLIBS=
20
21# ++ Coco =========
22# Default: autodetect gccasm/setjmp/ucontext/fibers context switch method.
23COCOCFLAGS=
24# Force use of setjmp (instead of gccasm).
25#COCOCFLAGS= -DCOCO_USE_SETJMP
26# Force use of ucontext (instead of gccasm or setjmp).
27#COCOCFLAGS= -DCOCO_USE_UCONTEXT
28# Uncomment this if you want to compile LuaJIT without Coco.
29# This effectively disables yielding from JIT compiled functions.
30#COCOCFLAGS= -DCOCO_DISABLE
31# -- Coco =========
32
33# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========
34
35PLATS= linux bsd macosx solaris mingw cygwin posix generic linux_rl bsd_rl macosx_rl
36
37# ++ Coco =========
38COCO_O= lcoco.o
39# -- Coco =========
40
41# ++ LuaJIT =========
42DASMDIR= ../dynasm
43DASMFLAGS=
44DASMDISTFLAGS= -LN
45
46# This assumes you already have a copy of (plain) Lua 5.1 installed
47# You can use luajit, too (built with the pre-processed headers from the dist)
48DASM= lua $(DASMDIR)/dynasm.lua
49
50JITCFLAGS= -I$(DASMDIR)
51JIT_O= ljit_core.o ljit_mem.o ljit_dasm.o ljit_backend.o
52JITLIB_O= ljitlib.o
53
54ALL_DH = ljit_x86.h
55# -- LuaJIT =========
56
57LUA_A= liblua.a
58CORE_O= lapi.o lcode.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o \
59 lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o \
60 lundump.o lvm.o lzio.o $(COCO_O) $(JIT_O)
61LIB_O= lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o \
62 lstrlib.o loadlib.o $(JITLIB_O) linit.o
63
64# Standalone has been renamed to avoid conflicts during installation
65LUA_T= luajit
66LUA_O= lua.o
67
68LUAC_T= luac
69LUAC_O= luac.o print.o
70
71ALL_O= $(CORE_O) $(LIB_O) $(LUA_O) $(LUAC_O)
72# Do not build luac by default
73#ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
74ALL_T= $(LUA_A) $(LUA_T)
75ALL_A= $(LUA_A)
76
77default: $(PLAT)
78
79all: $(ALL_T)
80
81o: $(ALL_O)
82
83a: $(ALL_A)
84
85$(LUA_A): $(CORE_O) $(LIB_O)
86 $(AR) $@ $?
87 $(RANLIB) $@
88
89$(LUA_T): $(LUA_O) $(LUA_A)
90 $(CC) -o $@ $(MYLDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
91
92$(LUAC_T): $(LUAC_O) $(LUA_A)
93 $(CC) -o $@ $(MYLDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
94
95# ++ LuaJIT =========
96ljit_x86.h: ljit_x86.dasc ljit_x86_inline.dash ljit_x86.dash
97 $(DASM) $(DASMFLAGS) -o $@ ljit_x86.dasc
98
99distclean: clean
100 $(DASM) $(DASMDISTFLAGS) -o ljit_x86.h ljit_x86.dasc
101
102cleaner: clean
103 $(RM) $(ALL_DH)
104# -- LuaJIT =========
105
106clean:
107 $(RM) $(ALL_T) $(ALL_O)
108
109depend:
110 @$(CC) $(CFLAGS) -MM l*.c print.c
111
112echo:
113 @echo "PLAT = $(PLAT)"
114 @echo "CC = $(CC)"
115 @echo "CFLAGS = $(CFLAGS)"
116 @echo "AR = $(AR)"
117 @echo "RANLIB = $(RANLIB)"
118 @echo "RM = $(RM)"
119 @echo "MYCFLAGS = $(MYCFLAGS)"
120 @echo "MYLDFLAGS = $(MYLDFLAGS)"
121 @echo "MYLIBS = $(MYLIBS)"
122
123# convenience targets for popular platforms
124
125none:
126 @echo "Please choose a platform:"
127 @echo " $(PLATS)"
128
129bsd:
130 $(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-Wl,-E"
131
132bsd_rl:
133 $(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN -DLUA_USE_READLINE" MYLIBS="-Wl,-E -lreadline"
134
135generic:
136 $(MAKE) all MYCFLAGS=
137
138linux:
139 $(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-Wl,-E -ldl"
140
141linux_rl:
142 $(MAKE) all MYCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE" MYLIBS="-Wl,-E -ldl -lreadline -lhistory -lncurses"
143
144# Mac OS X on Intel Macs only!
145macosx:
146 $(MAKE) all MYCFLAGS=-DLUA_USE_LINUX
147# use this on Mac OS X 10.3
148# $(MAKE) all MYCFLAGS=-DLUA_USE_MACOSX
149
150macosx_rl:
151 $(MAKE) all MYCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE" MYLIBS="-lreadline"
152
153mingw:
154 $(MAKE) "LUA_A=lua51.dll" "LUA_T=luajit.exe" \
155 "AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
156 "MYCFLAGS=-DLUA_BUILD_AS_DLL -maccumulate-outgoing-args" \
157 "MYLIBS=" "MYLDFLAGS=-s" luajit.exe
158
159cygwin:
160 $(MAKE) "CC=gcc -mno-cygwin" mingw
161
162posix:
163 $(MAKE) all MYCFLAGS=-DLUA_USE_POSIX
164
165# Solaris x86 only!
166solaris:
167 $(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl"
168
169# list targets that do not create files (but not all makes understand .PHONY)
170.PHONY: all $(PLATS) default o a clean depend echo none cleaner distclean
171
172# DO NOT DELETE
173
174lapi.o: lapi.c lua.h luaconf.h lapi.h lobject.h llimits.h ldebug.h \
175 lstate.h ltm.h lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h lstring.h \
176 ltable.h lundump.h lvm.h
177lauxlib.o: lauxlib.c lua.h luaconf.h lauxlib.h
178lbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h lcoco.h
179lcoco.o: lcoco.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \
180 lzio.h lmem.h lcoco.h ldo.h lvm.h lgc.h
181lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
182 lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h lcoco.h \
183 ldo.h lgc.h ltable.h
184ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h
185ldebug.o: ldebug.c lua.h luaconf.h lapi.h lobject.h llimits.h lcode.h \
186 llex.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h \
187 lcoco.h ldo.h lfunc.h lstring.h lgc.h ltable.h lvm.h ljit.h
188ldo.o: ldo.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
189 lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h lopcodes.h lparser.h \
190 lstring.h ltable.h lundump.h lvm.h ljit.h
191ldump.o: ldump.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \
192 lzio.h lmem.h lcoco.h lundump.h
193lfunc.o: lfunc.c lua.h luaconf.h lfunc.h lobject.h llimits.h lgc.h lmem.h \
194 lstate.h ltm.h lzio.h lcoco.h ljit.h
195lgc.o: lgc.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
196 lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h lstring.h ltable.h
197linit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h
198liolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h
199ljit_backend.o: ljit_backend.c lua.h luaconf.h lobject.h llimits.h \
200 lstate.h ltm.h lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h lstring.h \
201 ltable.h lvm.h lopcodes.h ldebug.h ljit.h ljit_hints.h ljit_dasm.h \
202 ../dynasm/dasm_proto.h ljit_x86.h
203ljit_core.o: ljit_core.c lua.h luaconf.h lobject.h llimits.h lstate.h \
204 ltm.h lzio.h lmem.h lcoco.h ldo.h lstring.h lgc.h ltable.h ldebug.h \
205 lopcodes.h ljit.h ljit_hints.h luajit.h
206ljit_dasm.o: ljit_dasm.c lua.h luaconf.h ljit.h lobject.h llimits.h \
207 ljit_dasm.h ../dynasm/dasm_proto.h lmem.h ../dynasm/dasm_x86.h
208ljit_mem.o: ljit_mem.c lua.h luaconf.h lmem.h llimits.h ldo.h lobject.h \
209 lstate.h ltm.h lzio.h lcoco.h ljit.h ljit_dasm.h ../dynasm/dasm_proto.h
210ljitlib.o: ljitlib.c lua.h luaconf.h lauxlib.h luajit.h lualib.h \
211 lobject.h llimits.h lstate.h ltm.h lzio.h lmem.h lcoco.h lstring.h \
212 lgc.h ltable.h lfunc.h lopcodes.h ljit.h ljit_hints.h
213llex.o: llex.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h ltm.h \
214 lzio.h lmem.h lcoco.h llex.h lparser.h lstring.h lgc.h ltable.h
215lmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h
216lmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
217 ltm.h lzio.h lmem.h lcoco.h ldo.h
218loadlib.o: loadlib.c lua.h luaconf.h lauxlib.h lualib.h luajit.h
219lobject.o: lobject.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h \
220 ltm.h lzio.h lmem.h lcoco.h lstring.h lgc.h lvm.h
221lopcodes.o: lopcodes.c lopcodes.h llimits.h lua.h luaconf.h
222loslib.o: loslib.c lua.h luaconf.h lauxlib.h lualib.h
223lparser.o: lparser.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
224 lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h lcoco.h \
225 ldo.h lfunc.h lstring.h lgc.h ltable.h
226lstate.o: lstate.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
227 ltm.h lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h llex.h lstring.h \
228 ltable.h ljit.h
229lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \
230 ltm.h lzio.h lcoco.h lstring.h lgc.h
231lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h
232ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
233 ltm.h lzio.h lmem.h lcoco.h ldo.h lgc.h ltable.h
234ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h
235ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \
236 lmem.h lcoco.h lstring.h lgc.h ltable.h
237lua.o: lua.c lua.h luaconf.h lauxlib.h lualib.h luajit.h
238luac.o: luac.c lua.h luaconf.h lauxlib.h ldo.h lobject.h llimits.h \
239 lstate.h ltm.h lzio.h lmem.h lcoco.h lfunc.h lopcodes.h lstring.h lgc.h \
240 lundump.h
241lundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
242 llimits.h ltm.h lzio.h lmem.h lcoco.h ldo.h lfunc.h lstring.h lgc.h \
243 lundump.h
244lvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
245 lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h \
246 lvm.h
247lzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \
248 lzio.h lcoco.h
249print.o: print.c ldebug.h lstate.h lua.h luaconf.h lobject.h llimits.h \
250 ltm.h lzio.h lmem.h lcoco.h lopcodes.h lundump.h
251
252# (end of Makefile)
diff --git a/libraries/LuaJIT-1.1.7/src/lapi.c b/libraries/LuaJIT-1.1.7/src/lapi.c
new file mode 100644
index 0000000..e8347a2
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lapi.c
@@ -0,0 +1,1082 @@
1/*
2** $Id: lapi.c,v 2.55.1.5 2008/07/04 18:41:18 roberto Exp $
3** Lua API
4** See Copyright Notice in lua.h
5*/
6
7
8#include <assert.h>
9#include <math.h>
10#include <stdarg.h>
11#include <string.h>
12
13#define lapi_c
14#define LUA_CORE
15
16#include "lua.h"
17
18#include "lapi.h"
19#include "ldebug.h"
20#include "ldo.h"
21#include "lfunc.h"
22#include "lgc.h"
23#include "lmem.h"
24#include "lobject.h"
25#include "lstate.h"
26#include "lstring.h"
27#include "ltable.h"
28#include "ltm.h"
29#include "lundump.h"
30#include "lvm.h"
31
32
33
34const char lua_ident[] =
35 "$Lua: " LUA_RELEASE " " LUA_COPYRIGHT " $\n"
36 "$Authors: " LUA_AUTHORS " $\n"
37 "$URL: www.lua.org $\n";
38
39
40
41#define api_checknelems(L, n) api_check(L, (n) <= (L->top - L->base))
42
43#define api_checkvalidindex(L, i) api_check(L, (i) != luaO_nilobject)
44
45#define api_incr_top(L) {api_check(L, L->top < L->ci->top); L->top++;}
46
47
48
49static TValue *index2adr (lua_State *L, int idx) {
50 if (idx > 0) {
51 TValue *o = L->base + (idx - 1);
52 api_check(L, idx <= L->ci->top - L->base);
53 if (o >= L->top) return cast(TValue *, luaO_nilobject);
54 else return o;
55 }
56 else if (idx > LUA_REGISTRYINDEX) {
57 api_check(L, idx != 0 && -idx <= L->top - L->base);
58 return L->top + idx;
59 }
60 else switch (idx) { /* pseudo-indices */
61 case LUA_REGISTRYINDEX: return registry(L);
62 case LUA_ENVIRONINDEX: {
63 Closure *func = curr_func(L);
64 sethvalue(L, &L->env, func->c.env);
65 return &L->env;
66 }
67 case LUA_GLOBALSINDEX: return gt(L);
68 default: {
69 Closure *func = curr_func(L);
70 idx = LUA_GLOBALSINDEX - idx;
71 return (idx <= func->c.nupvalues)
72 ? &func->c.upvalue[idx-1]
73 : cast(TValue *, luaO_nilobject);
74 }
75 }
76}
77
78
79static Table *getcurrenv (lua_State *L) {
80 if (L->ci == L->base_ci) /* no enclosing function? */
81 return hvalue(gt(L)); /* use global table as environment */
82 else {
83 Closure *func = curr_func(L);
84 return func->c.env;
85 }
86}
87
88
89void luaA_pushobject (lua_State *L, const TValue *o) {
90 setobj2s(L, L->top, o);
91 api_incr_top(L);
92}
93
94
95LUA_API int lua_checkstack (lua_State *L, int size) {
96 int res = 1;
97 lua_lock(L);
98 if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK)
99 res = 0; /* stack overflow */
100 else if (size > 0) {
101 luaD_checkstack(L, size);
102 if (L->ci->top < L->top + size)
103 L->ci->top = L->top + size;
104 }
105 lua_unlock(L);
106 return res;
107}
108
109
110LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
111 StkId f, t;
112 if (from == to) return;
113 lua_lock(to);
114 api_checknelems(from, n);
115 api_check(from, G(from) == G(to));
116 api_check(from, to->ci->top - to->top >= n);
117 f = from->top;
118 t = to->top = to->top + n;
119 while (--n >= 0) setobj2s(to, --t, --f);
120 from->top = f;
121 lua_unlock(to);
122}
123
124
125LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
126 lua_CFunction old;
127 lua_lock(L);
128 old = G(L)->panic;
129 G(L)->panic = panicf;
130 lua_unlock(L);
131 return old;
132}
133
134
135LUA_API lua_State *lua_newthread (lua_State *L) {
136 lua_State *L1;
137 lua_lock(L);
138 luaC_checkGC(L);
139 L1 = luaE_newthread(L);
140 setthvalue(L, L->top, L1);
141 api_incr_top(L);
142 lua_unlock(L);
143 luai_userstatethread(L, L1);
144 return L1;
145}
146
147
148
149/*
150** basic stack manipulation
151*/
152
153
154LUA_API int lua_gettop (lua_State *L) {
155 return cast_int(L->top - L->base);
156}
157
158
159LUA_API void lua_settop (lua_State *L, int idx) {
160 lua_lock(L);
161 if (idx >= 0) {
162 api_check(L, idx <= L->stack_last - L->base);
163 while (L->top < L->base + idx)
164 setnilvalue(L->top++);
165 L->top = L->base + idx;
166 }
167 else {
168 api_check(L, -(idx+1) <= (L->top - L->base));
169 L->top += idx+1; /* `subtract' index (index is negative) */
170 }
171 lua_unlock(L);
172}
173
174
175LUA_API void lua_remove (lua_State *L, int idx) {
176 StkId p;
177 lua_lock(L);
178 p = index2adr(L, idx);
179 api_checkvalidindex(L, p);
180 while (++p < L->top) setobjs2s(L, p-1, p);
181 L->top--;
182 lua_unlock(L);
183}
184
185
186LUA_API void lua_insert (lua_State *L, int idx) {
187 StkId p;
188 StkId q;
189 lua_lock(L);
190 p = index2adr(L, idx);
191 api_checkvalidindex(L, p);
192 for (q = L->top; q>p; q--) setobjs2s(L, q, q-1);
193 setobjs2s(L, p, L->top);
194 lua_unlock(L);
195}
196
197
198LUA_API void lua_replace (lua_State *L, int idx) {
199 StkId o;
200 lua_lock(L);
201 /* explicit test for incompatible code */
202 if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci)
203 luaG_runerror(L, "no calling environment");
204 api_checknelems(L, 1);
205 o = index2adr(L, idx);
206 api_checkvalidindex(L, o);
207 if (idx == LUA_ENVIRONINDEX) {
208 Closure *func = curr_func(L);
209 api_check(L, ttistable(L->top - 1));
210 func->c.env = hvalue(L->top - 1);
211 luaC_barrier(L, func, L->top - 1);
212 }
213 else {
214 setobj(L, o, L->top - 1);
215 if (idx < LUA_GLOBALSINDEX) /* function upvalue? */
216 luaC_barrier(L, curr_func(L), L->top - 1);
217 }
218 L->top--;
219 lua_unlock(L);
220}
221
222
223LUA_API void lua_pushvalue (lua_State *L, int idx) {
224 lua_lock(L);
225 setobj2s(L, L->top, index2adr(L, idx));
226 api_incr_top(L);
227 lua_unlock(L);
228}
229
230
231
232/*
233** access functions (stack -> C)
234*/
235
236
237LUA_API int lua_type (lua_State *L, int idx) {
238 StkId o = index2adr(L, idx);
239 return (o == luaO_nilobject) ? LUA_TNONE : ttype(o);
240}
241
242
243LUA_API const char *lua_typename (lua_State *L, int t) {
244 UNUSED(L);
245 return (t == LUA_TNONE) ? "no value" : luaT_typenames[t];
246}
247
248
249LUA_API int lua_iscfunction (lua_State *L, int idx) {
250 StkId o = index2adr(L, idx);
251 return iscfunction(o);
252}
253
254
255LUA_API int lua_isnumber (lua_State *L, int idx) {
256 TValue n;
257 const TValue *o = index2adr(L, idx);
258 return tonumber(o, &n);
259}
260
261
262LUA_API int lua_isstring (lua_State *L, int idx) {
263 int t = lua_type(L, idx);
264 return (t == LUA_TSTRING || t == LUA_TNUMBER);
265}
266
267
268LUA_API int lua_isuserdata (lua_State *L, int idx) {
269 const TValue *o = index2adr(L, idx);
270 return (ttisuserdata(o) || ttislightuserdata(o));
271}
272
273
274LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
275 StkId o1 = index2adr(L, index1);
276 StkId o2 = index2adr(L, index2);
277 return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
278 : luaO_rawequalObj(o1, o2);
279}
280
281
282LUA_API int lua_equal (lua_State *L, int index1, int index2) {
283 StkId o1, o2;
284 int i;
285 lua_lock(L); /* may call tag method */
286 o1 = index2adr(L, index1);
287 o2 = index2adr(L, index2);
288 i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 : equalobj(L, o1, o2);
289 lua_unlock(L);
290 return i;
291}
292
293
294LUA_API int lua_lessthan (lua_State *L, int index1, int index2) {
295 StkId o1, o2;
296 int i;
297 lua_lock(L); /* may call tag method */
298 o1 = index2adr(L, index1);
299 o2 = index2adr(L, index2);
300 i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
301 : luaV_lessthan(L, o1, o2);
302 lua_unlock(L);
303 return i;
304}
305
306
307
308LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {
309 TValue n;
310 const TValue *o = index2adr(L, idx);
311 if (tonumber(o, &n))
312 return nvalue(o);
313 else
314 return 0;
315}
316
317
318LUA_API lua_Integer lua_tointeger (lua_State *L, int idx) {
319 TValue n;
320 const TValue *o = index2adr(L, idx);
321 if (tonumber(o, &n)) {
322 lua_Integer res;
323 lua_Number num = nvalue(o);
324 lua_number2integer(res, num);
325 return res;
326 }
327 else
328 return 0;
329}
330
331
332LUA_API int lua_toboolean (lua_State *L, int idx) {
333 const TValue *o = index2adr(L, idx);
334 return !l_isfalse(o);
335}
336
337
338LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
339 StkId o = index2adr(L, idx);
340 if (!ttisstring(o)) {
341 lua_lock(L); /* `luaV_tostring' may create a new string */
342 if (!luaV_tostring(L, o)) { /* conversion failed? */
343 if (len != NULL) *len = 0;
344 lua_unlock(L);
345 return NULL;
346 }
347 luaC_checkGC(L);
348 o = index2adr(L, idx); /* previous call may reallocate the stack */
349 lua_unlock(L);
350 }
351 if (len != NULL) *len = tsvalue(o)->len;
352 return svalue(o);
353}
354
355
356LUA_API size_t lua_objlen (lua_State *L, int idx) {
357 StkId o = index2adr(L, idx);
358 switch (ttype(o)) {
359 case LUA_TSTRING: return tsvalue(o)->len;
360 case LUA_TUSERDATA: return uvalue(o)->len;
361 case LUA_TTABLE: return luaH_getn(hvalue(o));
362 case LUA_TNUMBER: {
363 size_t l;
364 lua_lock(L); /* `luaV_tostring' may create a new string */
365 l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0);
366 lua_unlock(L);
367 return l;
368 }
369 default: return 0;
370 }
371}
372
373
374LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
375 StkId o = index2adr(L, idx);
376 return (!iscfunction(o)) ? NULL : clvalue(o)->c.f;
377}
378
379
380LUA_API void *lua_touserdata (lua_State *L, int idx) {
381 StkId o = index2adr(L, idx);
382 switch (ttype(o)) {
383 case LUA_TUSERDATA: return (rawuvalue(o) + 1);
384 case LUA_TLIGHTUSERDATA: return pvalue(o);
385 default: return NULL;
386 }
387}
388
389
390LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
391 StkId o = index2adr(L, idx);
392 return (!ttisthread(o)) ? NULL : thvalue(o);
393}
394
395
396LUA_API const void *lua_topointer (lua_State *L, int idx) {
397 StkId o = index2adr(L, idx);
398 switch (ttype(o)) {
399 case LUA_TTABLE: return hvalue(o);
400 case LUA_TFUNCTION: return clvalue(o);
401 case LUA_TTHREAD: return thvalue(o);
402 case LUA_TUSERDATA:
403 case LUA_TLIGHTUSERDATA:
404 return lua_touserdata(L, idx);
405 default: return NULL;
406 }
407}
408
409
410
411/*
412** push functions (C -> stack)
413*/
414
415
416LUA_API void lua_pushnil (lua_State *L) {
417 lua_lock(L);
418 setnilvalue(L->top);
419 api_incr_top(L);
420 lua_unlock(L);
421}
422
423
424LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
425 lua_lock(L);
426 setnvalue(L->top, n);
427 api_incr_top(L);
428 lua_unlock(L);
429}
430
431
432LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
433 lua_lock(L);
434 setnvalue(L->top, cast_num(n));
435 api_incr_top(L);
436 lua_unlock(L);
437}
438
439
440LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
441 lua_lock(L);
442 luaC_checkGC(L);
443 setsvalue2s(L, L->top, luaS_newlstr(L, s, len));
444 api_incr_top(L);
445 lua_unlock(L);
446}
447
448
449LUA_API void lua_pushstring (lua_State *L, const char *s) {
450 if (s == NULL)
451 lua_pushnil(L);
452 else
453 lua_pushlstring(L, s, strlen(s));
454}
455
456
457LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
458 va_list argp) {
459 const char *ret;
460 lua_lock(L);
461 luaC_checkGC(L);
462 ret = luaO_pushvfstring(L, fmt, argp);
463 lua_unlock(L);
464 return ret;
465}
466
467
468LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
469 const char *ret;
470 va_list argp;
471 lua_lock(L);
472 luaC_checkGC(L);
473 va_start(argp, fmt);
474 ret = luaO_pushvfstring(L, fmt, argp);
475 va_end(argp);
476 lua_unlock(L);
477 return ret;
478}
479
480
481LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
482 Closure *cl;
483 lua_lock(L);
484 luaC_checkGC(L);
485 api_checknelems(L, n);
486 cl = luaF_newCclosure(L, n, getcurrenv(L));
487 cl->c.f = fn;
488 L->top -= n;
489 while (n--)
490 setobj2n(L, &cl->c.upvalue[n], L->top+n);
491 setclvalue(L, L->top, cl);
492 lua_assert(iswhite(obj2gco(cl)));
493 api_incr_top(L);
494 lua_unlock(L);
495}
496
497
498LUA_API void lua_pushboolean (lua_State *L, int b) {
499 lua_lock(L);
500 setbvalue(L->top, (b != 0)); /* ensure that true is 1 */
501 api_incr_top(L);
502 lua_unlock(L);
503}
504
505
506LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {
507 lua_lock(L);
508 setpvalue(L->top, p);
509 api_incr_top(L);
510 lua_unlock(L);
511}
512
513
514LUA_API int lua_pushthread (lua_State *L) {
515 lua_lock(L);
516 setthvalue(L, L->top, L);
517 api_incr_top(L);
518 lua_unlock(L);
519 return (G(L)->mainthread == L);
520}
521
522
523
524/*
525** get functions (Lua -> stack)
526*/
527
528
529LUA_API void lua_gettable (lua_State *L, int idx) {
530 StkId t;
531 lua_lock(L);
532 t = index2adr(L, idx);
533 api_checkvalidindex(L, t);
534 luaV_gettable(L, t, L->top - 1, L->top - 1);
535 lua_unlock(L);
536}
537
538
539LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
540 StkId t;
541 TValue key;
542 lua_lock(L);
543 t = index2adr(L, idx);
544 api_checkvalidindex(L, t);
545 setsvalue(L, &key, luaS_new(L, k));
546 luaV_gettable(L, t, &key, L->top);
547 api_incr_top(L);
548 lua_unlock(L);
549}
550
551
552LUA_API void lua_rawget (lua_State *L, int idx) {
553 StkId t;
554 lua_lock(L);
555 t = index2adr(L, idx);
556 api_check(L, ttistable(t));
557 setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
558 lua_unlock(L);
559}
560
561
562LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
563 StkId o;
564 lua_lock(L);
565 o = index2adr(L, idx);
566 api_check(L, ttistable(o));
567 setobj2s(L, L->top, luaH_getnum(hvalue(o), n));
568 api_incr_top(L);
569 lua_unlock(L);
570}
571
572
573LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
574 lua_lock(L);
575 luaC_checkGC(L);
576 sethvalue(L, L->top, luaH_new(L, narray, nrec));
577 api_incr_top(L);
578 lua_unlock(L);
579}
580
581
582LUA_API int lua_getmetatable (lua_State *L, int objindex) {
583 const TValue *obj;
584 Table *mt = NULL;
585 int res;
586 lua_lock(L);
587 obj = index2adr(L, objindex);
588 switch (ttype(obj)) {
589 case LUA_TTABLE:
590 mt = hvalue(obj)->metatable;
591 break;
592 case LUA_TUSERDATA:
593 mt = uvalue(obj)->metatable;
594 break;
595 default:
596 mt = G(L)->mt[ttype(obj)];
597 break;
598 }
599 if (mt == NULL)
600 res = 0;
601 else {
602 sethvalue(L, L->top, mt);
603 api_incr_top(L);
604 res = 1;
605 }
606 lua_unlock(L);
607 return res;
608}
609
610
611LUA_API void lua_getfenv (lua_State *L, int idx) {
612 StkId o;
613 lua_lock(L);
614 o = index2adr(L, idx);
615 api_checkvalidindex(L, o);
616 switch (ttype(o)) {
617 case LUA_TFUNCTION:
618 sethvalue(L, L->top, clvalue(o)->c.env);
619 break;
620 case LUA_TUSERDATA:
621 sethvalue(L, L->top, uvalue(o)->env);
622 break;
623 case LUA_TTHREAD:
624 setobj2s(L, L->top, gt(thvalue(o)));
625 break;
626 default:
627 setnilvalue(L->top);
628 break;
629 }
630 api_incr_top(L);
631 lua_unlock(L);
632}
633
634
635/*
636** set functions (stack -> Lua)
637*/
638
639
640LUA_API void lua_settable (lua_State *L, int idx) {
641 StkId t;
642 lua_lock(L);
643 api_checknelems(L, 2);
644 t = index2adr(L, idx);
645 api_checkvalidindex(L, t);
646 luaV_settable(L, t, L->top - 2, L->top - 1);
647 L->top -= 2; /* pop index and value */
648 lua_unlock(L);
649}
650
651
652LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
653 StkId t;
654 TValue key;
655 lua_lock(L);
656 api_checknelems(L, 1);
657 t = index2adr(L, idx);
658 api_checkvalidindex(L, t);
659 setsvalue(L, &key, luaS_new(L, k));
660 luaV_settable(L, t, &key, L->top - 1);
661 L->top--; /* pop value */
662 lua_unlock(L);
663}
664
665
666LUA_API void lua_rawset (lua_State *L, int idx) {
667 StkId t;
668 lua_lock(L);
669 api_checknelems(L, 2);
670 t = index2adr(L, idx);
671 api_check(L, ttistable(t));
672 setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
673 luaC_barriert(L, hvalue(t), L->top-1);
674 L->top -= 2;
675 lua_unlock(L);
676}
677
678
679LUA_API void lua_rawseti (lua_State *L, int idx, int n) {
680 StkId o;
681 lua_lock(L);
682 api_checknelems(L, 1);
683 o = index2adr(L, idx);
684 api_check(L, ttistable(o));
685 setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);
686 luaC_barriert(L, hvalue(o), L->top-1);
687 L->top--;
688 lua_unlock(L);
689}
690
691
692LUA_API int lua_setmetatable (lua_State *L, int objindex) {
693 TValue *obj;
694 Table *mt;
695 lua_lock(L);
696 api_checknelems(L, 1);
697 obj = index2adr(L, objindex);
698 api_checkvalidindex(L, obj);
699 if (ttisnil(L->top - 1))
700 mt = NULL;
701 else {
702 api_check(L, ttistable(L->top - 1));
703 mt = hvalue(L->top - 1);
704 }
705 switch (ttype(obj)) {
706 case LUA_TTABLE: {
707 hvalue(obj)->metatable = mt;
708 if (mt)
709 luaC_objbarriert(L, hvalue(obj), mt);
710 break;
711 }
712 case LUA_TUSERDATA: {
713 uvalue(obj)->metatable = mt;
714 if (mt)
715 luaC_objbarrier(L, rawuvalue(obj), mt);
716 break;
717 }
718 default: {
719 G(L)->mt[ttype(obj)] = mt;
720 break;
721 }
722 }
723 L->top--;
724 lua_unlock(L);
725 return 1;
726}
727
728
729LUA_API int lua_setfenv (lua_State *L, int idx) {
730 StkId o;
731 int res = 1;
732 lua_lock(L);
733 api_checknelems(L, 1);
734 o = index2adr(L, idx);
735 api_checkvalidindex(L, o);
736 api_check(L, ttistable(L->top - 1));
737 switch (ttype(o)) {
738 case LUA_TFUNCTION:
739 clvalue(o)->c.env = hvalue(L->top - 1);
740 break;
741 case LUA_TUSERDATA:
742 uvalue(o)->env = hvalue(L->top - 1);
743 break;
744 case LUA_TTHREAD:
745 sethvalue(L, gt(thvalue(o)), hvalue(L->top - 1));
746 break;
747 default:
748 res = 0;
749 break;
750 }
751 if (res) luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
752 L->top--;
753 lua_unlock(L);
754 return res;
755}
756
757
758/*
759** `load' and `call' functions (run Lua code)
760*/
761
762
763#define adjustresults(L,nres) \
764 { if (nres == LUA_MULTRET && L->top >= L->ci->top) L->ci->top = L->top; }
765
766
767#define checkresults(L,na,nr) \
768 api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)))
769
770
771LUA_API void lua_call (lua_State *L, int nargs, int nresults) {
772 StkId func;
773 lua_lock(L);
774 api_checknelems(L, nargs+1);
775 checkresults(L, nargs, nresults);
776 func = L->top - (nargs+1);
777 luaD_call(L, func, nresults);
778 adjustresults(L, nresults);
779 lua_unlock(L);
780}
781
782
783
784/*
785** Execute a protected call.
786*/
787struct CallS { /* data to `f_call' */
788 StkId func;
789 int nresults;
790};
791
792
793static void f_call (lua_State *L, void *ud) {
794 struct CallS *c = cast(struct CallS *, ud);
795 luaD_call(L, c->func, c->nresults);
796}
797
798
799
800LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {
801 struct CallS c;
802 int status;
803 ptrdiff_t func;
804 lua_lock(L);
805 api_checknelems(L, nargs+1);
806 checkresults(L, nargs, nresults);
807 if (errfunc == 0)
808 func = 0;
809 else {
810 StkId o = index2adr(L, errfunc);
811 api_checkvalidindex(L, o);
812 func = savestack(L, o);
813 }
814 c.func = L->top - (nargs+1); /* function to be called */
815 c.nresults = nresults;
816 status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
817 adjustresults(L, nresults);
818 lua_unlock(L);
819 return status;
820}
821
822
823/*
824** Execute a protected C call.
825*/
826struct CCallS { /* data to `f_Ccall' */
827 lua_CFunction func;
828 void *ud;
829};
830
831
832static void f_Ccall (lua_State *L, void *ud) {
833 struct CCallS *c = cast(struct CCallS *, ud);
834 Closure *cl;
835 cl = luaF_newCclosure(L, 0, getcurrenv(L));
836 cl->c.f = c->func;
837 setclvalue(L, L->top, cl); /* push function */
838 api_incr_top(L);
839 setpvalue(L->top, c->ud); /* push only argument */
840 api_incr_top(L);
841 luaD_call(L, L->top - 2, 0);
842}
843
844
845LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) {
846 struct CCallS c;
847 int status;
848 lua_lock(L);
849 c.func = func;
850 c.ud = ud;
851 status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0);
852 lua_unlock(L);
853 return status;
854}
855
856
857LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
858 const char *chunkname) {
859 ZIO z;
860 int status;
861 lua_lock(L);
862 if (!chunkname) chunkname = "?";
863 luaZ_init(L, &z, reader, data);
864 status = luaD_protectedparser(L, &z, chunkname);
865 lua_unlock(L);
866 return status;
867}
868
869
870LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {
871 int status;
872 TValue *o;
873 lua_lock(L);
874 api_checknelems(L, 1);
875 o = L->top - 1;
876 if (isLfunction(o))
877 status = luaU_dump(L, clvalue(o)->l.p, writer, data, 0);
878 else
879 status = 1;
880 lua_unlock(L);
881 return status;
882}
883
884
885LUA_API int lua_status (lua_State *L) {
886 return L->status;
887}
888
889
890/*
891** Garbage-collection function
892*/
893
894LUA_API int lua_gc (lua_State *L, int what, int data) {
895 int res = 0;
896 global_State *g;
897 lua_lock(L);
898 g = G(L);
899 switch (what) {
900 case LUA_GCSTOP: {
901 g->GCthreshold = MAX_LUMEM;
902 break;
903 }
904 case LUA_GCRESTART: {
905 g->GCthreshold = g->totalbytes;
906 break;
907 }
908 case LUA_GCCOLLECT: {
909 luaC_fullgc(L);
910 break;
911 }
912 case LUA_GCCOUNT: {
913 /* GC values are expressed in Kbytes: #bytes/2^10 */
914 res = cast_int(g->totalbytes >> 10);
915 break;
916 }
917 case LUA_GCCOUNTB: {
918 res = cast_int(g->totalbytes & 0x3ff);
919 break;
920 }
921 case LUA_GCSTEP: {
922 lu_mem a = (cast(lu_mem, data) << 10);
923 if (a <= g->totalbytes)
924 g->GCthreshold = g->totalbytes - a;
925 else
926 g->GCthreshold = 0;
927 while (g->GCthreshold <= g->totalbytes) {
928 luaC_step(L);
929 if (g->gcstate == GCSpause) { /* end of cycle? */
930 res = 1; /* signal it */
931 break;
932 }
933 }
934 break;
935 }
936 case LUA_GCSETPAUSE: {
937 res = g->gcpause;
938 g->gcpause = data;
939 break;
940 }
941 case LUA_GCSETSTEPMUL: {
942 res = g->gcstepmul;
943 g->gcstepmul = data;
944 break;
945 }
946 default: res = -1; /* invalid option */
947 }
948 lua_unlock(L);
949 return res;
950}
951
952
953
954/*
955** miscellaneous functions
956*/
957
958
959LUA_API int lua_error (lua_State *L) {
960 lua_lock(L);
961 api_checknelems(L, 1);
962 luaG_errormsg(L);
963 lua_unlock(L);
964 return 0; /* to avoid warnings */
965}
966
967
968LUA_API int lua_next (lua_State *L, int idx) {
969 StkId t;
970 int more;
971 lua_lock(L);
972 t = index2adr(L, idx);
973 api_check(L, ttistable(t));
974 more = luaH_next(L, hvalue(t), L->top - 1);
975 if (more) {
976 api_incr_top(L);
977 }
978 else /* no more elements */
979 L->top -= 1; /* remove key */
980 lua_unlock(L);
981 return more;
982}
983
984
985LUA_API void lua_concat (lua_State *L, int n) {
986 lua_lock(L);
987 api_checknelems(L, n);
988 if (n >= 2) {
989 luaC_checkGC(L);
990 luaV_concat(L, n, cast_int(L->top - L->base) - 1);
991 L->top -= (n-1);
992 }
993 else if (n == 0) { /* push empty string */
994 setsvalue2s(L, L->top, luaS_newlstr(L, "", 0));
995 api_incr_top(L);
996 }
997 /* else n == 1; nothing to do */
998 lua_unlock(L);
999}
1000
1001
1002LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) {
1003 lua_Alloc f;
1004 lua_lock(L);
1005 if (ud) *ud = G(L)->ud;
1006 f = G(L)->frealloc;
1007 lua_unlock(L);
1008 return f;
1009}
1010
1011
1012LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) {
1013 lua_lock(L);
1014 G(L)->ud = ud;
1015 G(L)->frealloc = f;
1016 lua_unlock(L);
1017}
1018
1019
1020LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
1021 Udata *u;
1022 lua_lock(L);
1023 luaC_checkGC(L);
1024 u = luaS_newudata(L, size, getcurrenv(L));
1025 setuvalue(L, L->top, u);
1026 api_incr_top(L);
1027 lua_unlock(L);
1028 return u + 1;
1029}
1030
1031
1032
1033
1034static const char *aux_upvalue (StkId fi, int n, TValue **val) {
1035 Closure *f;
1036 if (!ttisfunction(fi)) return NULL;
1037 f = clvalue(fi);
1038 if (f->c.isC) {
1039 if (!(1 <= n && n <= f->c.nupvalues)) return NULL;
1040 *val = &f->c.upvalue[n-1];
1041 return "";
1042 }
1043 else {
1044 Proto *p = f->l.p;
1045 if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
1046 *val = f->l.upvals[n-1]->v;
1047 return getstr(p->upvalues[n-1]);
1048 }
1049}
1050
1051
1052LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
1053 const char *name;
1054 TValue *val;
1055 lua_lock(L);
1056 name = aux_upvalue(index2adr(L, funcindex), n, &val);
1057 if (name) {
1058 setobj2s(L, L->top, val);
1059 api_incr_top(L);
1060 }
1061 lua_unlock(L);
1062 return name;
1063}
1064
1065
1066LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
1067 const char *name;
1068 TValue *val;
1069 StkId fi;
1070 lua_lock(L);
1071 fi = index2adr(L, funcindex);
1072 api_checknelems(L, 1);
1073 name = aux_upvalue(fi, n, &val);
1074 if (name) {
1075 L->top--;
1076 setobj(L, val, L->top);
1077 luaC_barrier(L, clvalue(fi), L->top);
1078 }
1079 lua_unlock(L);
1080 return name;
1081}
1082
diff --git a/libraries/LuaJIT-1.1.7/src/lapi.h b/libraries/LuaJIT-1.1.7/src/lapi.h
new file mode 100644
index 0000000..2c3fab2
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lapi.h
@@ -0,0 +1,16 @@
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
14LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o);
15
16#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lauxlib.c b/libraries/LuaJIT-1.1.7/src/lauxlib.c
new file mode 100644
index 0000000..10f14e2
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lauxlib.c
@@ -0,0 +1,652 @@
1/*
2** $Id: lauxlib.c,v 1.159.1.3 2008/01/21 13:20:51 roberto Exp $
3** Auxiliary functions for building Lua libraries
4** See Copyright Notice in lua.h
5*/
6
7
8#include <ctype.h>
9#include <errno.h>
10#include <stdarg.h>
11#include <stdio.h>
12#include <stdlib.h>
13#include <string.h>
14
15
16/* This file uses only the official API of Lua.
17** Any function declared here could be written as an application function.
18*/
19
20#define lauxlib_c
21#define LUA_LIB
22
23#include "lua.h"
24
25#include "lauxlib.h"
26
27
28#define FREELIST_REF 0 /* free list of references */
29
30
31/* convert a stack index to positive */
32#define abs_index(L, i) ((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : \
33 lua_gettop(L) + (i) + 1)
34
35
36/*
37** {======================================================
38** Error-report functions
39** =======================================================
40*/
41
42
43LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
44 lua_Debug ar;
45 if (!lua_getstack(L, 0, &ar)) /* no stack frame? */
46 return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
47 lua_getinfo(L, "n", &ar);
48 if (strcmp(ar.namewhat, "method") == 0) {
49 narg--; /* do not count `self' */
50 if (narg == 0) /* error is in the self argument itself? */
51 return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
52 ar.name, extramsg);
53 }
54 if (ar.name == NULL)
55 ar.name = "?";
56 return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
57 narg, ar.name, extramsg);
58}
59
60
61LUALIB_API int luaL_typerror (lua_State *L, int narg, const char *tname) {
62 const char *msg = lua_pushfstring(L, "%s expected, got %s",
63 tname, luaL_typename(L, narg));
64 return luaL_argerror(L, narg, msg);
65}
66
67
68static void tag_error (lua_State *L, int narg, int tag) {
69 luaL_typerror(L, narg, lua_typename(L, tag));
70}
71
72
73LUALIB_API void luaL_where (lua_State *L, int level) {
74 lua_Debug ar;
75 if (lua_getstack(L, level, &ar)) { /* check function at level */
76 lua_getinfo(L, "Sl", &ar); /* get info about it */
77 if (ar.currentline > 0) { /* is there info? */
78 lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);
79 return;
80 }
81 }
82 lua_pushliteral(L, ""); /* else, no information available... */
83}
84
85
86LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
87 va_list argp;
88 va_start(argp, fmt);
89 luaL_where(L, 1);
90 lua_pushvfstring(L, fmt, argp);
91 va_end(argp);
92 lua_concat(L, 2);
93 return lua_error(L);
94}
95
96/* }====================================================== */
97
98
99LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
100 const char *const lst[]) {
101 const char *name = (def) ? luaL_optstring(L, narg, def) :
102 luaL_checkstring(L, narg);
103 int i;
104 for (i=0; lst[i]; i++)
105 if (strcmp(lst[i], name) == 0)
106 return i;
107 return luaL_argerror(L, narg,
108 lua_pushfstring(L, "invalid option " LUA_QS, name));
109}
110
111
112LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
113 lua_getfield(L, LUA_REGISTRYINDEX, tname); /* get registry.name */
114 if (!lua_isnil(L, -1)) /* name already in use? */
115 return 0; /* leave previous value on top, but return 0 */
116 lua_pop(L, 1);
117 lua_newtable(L); /* create metatable */
118 lua_pushvalue(L, -1);
119 lua_setfield(L, LUA_REGISTRYINDEX, tname); /* registry.name = metatable */
120 return 1;
121}
122
123
124LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
125 void *p = lua_touserdata(L, ud);
126 if (p != NULL) { /* value is a userdata? */
127 if (lua_getmetatable(L, ud)) { /* does it have a metatable? */
128 lua_getfield(L, LUA_REGISTRYINDEX, tname); /* get correct metatable */
129 if (lua_rawequal(L, -1, -2)) { /* does it have the correct mt? */
130 lua_pop(L, 2); /* remove both metatables */
131 return p;
132 }
133 }
134 }
135 luaL_typerror(L, ud, tname); /* else error */
136 return NULL; /* to avoid warnings */
137}
138
139
140LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) {
141 if (!lua_checkstack(L, space))
142 luaL_error(L, "stack overflow (%s)", mes);
143}
144
145
146LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {
147 if (lua_type(L, narg) != t)
148 tag_error(L, narg, t);
149}
150
151
152LUALIB_API void luaL_checkany (lua_State *L, int narg) {
153 if (lua_type(L, narg) == LUA_TNONE)
154 luaL_argerror(L, narg, "value expected");
155}
156
157
158LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {
159 const char *s = lua_tolstring(L, narg, len);
160 if (!s) tag_error(L, narg, LUA_TSTRING);
161 return s;
162}
163
164
165LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
166 const char *def, size_t *len) {
167 if (lua_isnoneornil(L, narg)) {
168 if (len)
169 *len = (def ? strlen(def) : 0);
170 return def;
171 }
172 else return luaL_checklstring(L, narg, len);
173}
174
175
176LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
177 lua_Number d = lua_tonumber(L, narg);
178 if (d == 0 && !lua_isnumber(L, narg)) /* avoid extra test when d is not 0 */
179 tag_error(L, narg, LUA_TNUMBER);
180 return d;
181}
182
183
184LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {
185 return luaL_opt(L, luaL_checknumber, narg, def);
186}
187
188
189LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
190 lua_Integer d = lua_tointeger(L, narg);
191 if (d == 0 && !lua_isnumber(L, narg)) /* avoid extra test when d is not 0 */
192 tag_error(L, narg, LUA_TNUMBER);
193 return d;
194}
195
196
197LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,
198 lua_Integer def) {
199 return luaL_opt(L, luaL_checkinteger, narg, def);
200}
201
202
203LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
204 if (!lua_getmetatable(L, obj)) /* no metatable? */
205 return 0;
206 lua_pushstring(L, event);
207 lua_rawget(L, -2);
208 if (lua_isnil(L, -1)) {
209 lua_pop(L, 2); /* remove metatable and metafield */
210 return 0;
211 }
212 else {
213 lua_remove(L, -2); /* remove only metatable */
214 return 1;
215 }
216}
217
218
219LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
220 obj = abs_index(L, obj);
221 if (!luaL_getmetafield(L, obj, event)) /* no metafield? */
222 return 0;
223 lua_pushvalue(L, obj);
224 lua_call(L, 1, 1);
225 return 1;
226}
227
228
229LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
230 const luaL_Reg *l) {
231 luaI_openlib(L, libname, l, 0);
232}
233
234
235static int libsize (const luaL_Reg *l) {
236 int size = 0;
237 for (; l->name; l++) size++;
238 return size;
239}
240
241
242LUALIB_API void luaI_openlib (lua_State *L, const char *libname,
243 const luaL_Reg *l, int nup) {
244 if (libname) {
245 int size = libsize(l);
246 /* check whether lib already exists */
247 luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);
248 lua_getfield(L, -1, libname); /* get _LOADED[libname] */
249 if (!lua_istable(L, -1)) { /* not found? */
250 lua_pop(L, 1); /* remove previous result */
251 /* try global variable (and create one if it does not exist) */
252 if (luaL_findtable(L, LUA_GLOBALSINDEX, libname, size) != NULL)
253 luaL_error(L, "name conflict for module " LUA_QS, libname);
254 lua_pushvalue(L, -1);
255 lua_setfield(L, -3, libname); /* _LOADED[libname] = new table */
256 }
257 lua_remove(L, -2); /* remove _LOADED table */
258 lua_insert(L, -(nup+1)); /* move library table to below upvalues */
259 }
260 for (; l->name; l++) {
261 int i;
262 for (i=0; i<nup; i++) /* copy upvalues to the top */
263 lua_pushvalue(L, -nup);
264 lua_pushcclosure(L, l->func, nup);
265 lua_setfield(L, -(nup+2), l->name);
266 }
267 lua_pop(L, nup); /* remove upvalues */
268}
269
270
271
272/*
273** {======================================================
274** getn-setn: size for arrays
275** =======================================================
276*/
277
278#if defined(LUA_COMPAT_GETN)
279
280static int checkint (lua_State *L, int topop) {
281 int n = (lua_type(L, -1) == LUA_TNUMBER) ? lua_tointeger(L, -1) : -1;
282 lua_pop(L, topop);
283 return n;
284}
285
286
287static void getsizes (lua_State *L) {
288 lua_getfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");
289 if (lua_isnil(L, -1)) { /* no `size' table? */
290 lua_pop(L, 1); /* remove nil */
291 lua_newtable(L); /* create it */
292 lua_pushvalue(L, -1); /* `size' will be its own metatable */
293 lua_setmetatable(L, -2);
294 lua_pushliteral(L, "kv");
295 lua_setfield(L, -2, "__mode"); /* metatable(N).__mode = "kv" */
296 lua_pushvalue(L, -1);
297 lua_setfield(L, LUA_REGISTRYINDEX, "LUA_SIZES"); /* store in register */
298 }
299}
300
301
302LUALIB_API void luaL_setn (lua_State *L, int t, int n) {
303 t = abs_index(L, t);
304 lua_pushliteral(L, "n");
305 lua_rawget(L, t);
306 if (checkint(L, 1) >= 0) { /* is there a numeric field `n'? */
307 lua_pushliteral(L, "n"); /* use it */
308 lua_pushinteger(L, n);
309 lua_rawset(L, t);
310 }
311 else { /* use `sizes' */
312 getsizes(L);
313 lua_pushvalue(L, t);
314 lua_pushinteger(L, n);
315 lua_rawset(L, -3); /* sizes[t] = n */
316 lua_pop(L, 1); /* remove `sizes' */
317 }
318}
319
320
321LUALIB_API int luaL_getn (lua_State *L, int t) {
322 int n;
323 t = abs_index(L, t);
324 lua_pushliteral(L, "n"); /* try t.n */
325 lua_rawget(L, t);
326 if ((n = checkint(L, 1)) >= 0) return n;
327 getsizes(L); /* else try sizes[t] */
328 lua_pushvalue(L, t);
329 lua_rawget(L, -2);
330 if ((n = checkint(L, 2)) >= 0) return n;
331 return (int)lua_objlen(L, t);
332}
333
334#endif
335
336/* }====================================================== */
337
338
339
340LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,
341 const char *r) {
342 const char *wild;
343 size_t l = strlen(p);
344 luaL_Buffer b;
345 luaL_buffinit(L, &b);
346 while ((wild = strstr(s, p)) != NULL) {
347 luaL_addlstring(&b, s, wild - s); /* push prefix */
348 luaL_addstring(&b, r); /* push replacement in place of pattern */
349 s = wild + l; /* continue after `p' */
350 }
351 luaL_addstring(&b, s); /* push last suffix */
352 luaL_pushresult(&b);
353 return lua_tostring(L, -1);
354}
355
356
357LUALIB_API const char *luaL_findtable (lua_State *L, int idx,
358 const char *fname, int szhint) {
359 const char *e;
360 lua_pushvalue(L, idx);
361 do {
362 e = strchr(fname, '.');
363 if (e == NULL) e = fname + strlen(fname);
364 lua_pushlstring(L, fname, e - fname);
365 lua_rawget(L, -2);
366 if (lua_isnil(L, -1)) { /* no such field? */
367 lua_pop(L, 1); /* remove this nil */
368 lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
369 lua_pushlstring(L, fname, e - fname);
370 lua_pushvalue(L, -2);
371 lua_settable(L, -4); /* set new table into field */
372 }
373 else if (!lua_istable(L, -1)) { /* field has a non-table value? */
374 lua_pop(L, 2); /* remove table and value */
375 return fname; /* return problematic part of the name */
376 }
377 lua_remove(L, -2); /* remove previous table */
378 fname = e + 1;
379 } while (*e == '.');
380 return NULL;
381}
382
383
384
385/*
386** {======================================================
387** Generic Buffer manipulation
388** =======================================================
389*/
390
391
392#define bufflen(B) ((B)->p - (B)->buffer)
393#define bufffree(B) ((size_t)(LUAL_BUFFERSIZE - bufflen(B)))
394
395#define LIMIT (LUA_MINSTACK/2)
396
397
398static int emptybuffer (luaL_Buffer *B) {
399 size_t l = bufflen(B);
400 if (l == 0) return 0; /* put nothing on stack */
401 else {
402 lua_pushlstring(B->L, B->buffer, l);
403 B->p = B->buffer;
404 B->lvl++;
405 return 1;
406 }
407}
408
409
410static void adjuststack (luaL_Buffer *B) {
411 if (B->lvl > 1) {
412 lua_State *L = B->L;
413 int toget = 1; /* number of levels to concat */
414 size_t toplen = lua_strlen(L, -1);
415 do {
416 size_t l = lua_strlen(L, -(toget+1));
417 if (B->lvl - toget + 1 >= LIMIT || toplen > l) {
418 toplen += l;
419 toget++;
420 }
421 else break;
422 } while (toget < B->lvl);
423 lua_concat(L, toget);
424 B->lvl = B->lvl - toget + 1;
425 }
426}
427
428
429LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
430 if (emptybuffer(B))
431 adjuststack(B);
432 return B->buffer;
433}
434
435
436LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
437 while (l--)
438 luaL_addchar(B, *s++);
439}
440
441
442LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {
443 luaL_addlstring(B, s, strlen(s));
444}
445
446
447LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
448 emptybuffer(B);
449 lua_concat(B->L, B->lvl);
450 B->lvl = 1;
451}
452
453
454LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
455 lua_State *L = B->L;
456 size_t vl;
457 const char *s = lua_tolstring(L, -1, &vl);
458 if (vl <= bufffree(B)) { /* fit into buffer? */
459 memcpy(B->p, s, vl); /* put it there */
460 B->p += vl;
461 lua_pop(L, 1); /* remove from stack */
462 }
463 else {
464 if (emptybuffer(B))
465 lua_insert(L, -2); /* put buffer before new value */
466 B->lvl++; /* add new value into B stack */
467 adjuststack(B);
468 }
469}
470
471
472LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
473 B->L = L;
474 B->p = B->buffer;
475 B->lvl = 0;
476}
477
478/* }====================================================== */
479
480
481LUALIB_API int luaL_ref (lua_State *L, int t) {
482 int ref;
483 t = abs_index(L, t);
484 if (lua_isnil(L, -1)) {
485 lua_pop(L, 1); /* remove from stack */
486 return LUA_REFNIL; /* `nil' has a unique fixed reference */
487 }
488 lua_rawgeti(L, t, FREELIST_REF); /* get first free element */
489 ref = (int)lua_tointeger(L, -1); /* ref = t[FREELIST_REF] */
490 lua_pop(L, 1); /* remove it from stack */
491 if (ref != 0) { /* any free element? */
492 lua_rawgeti(L, t, ref); /* remove it from list */
493 lua_rawseti(L, t, FREELIST_REF); /* (t[FREELIST_REF] = t[ref]) */
494 }
495 else { /* no free elements */
496 ref = (int)lua_objlen(L, t);
497 ref++; /* create new reference */
498 }
499 lua_rawseti(L, t, ref);
500 return ref;
501}
502
503
504LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
505 if (ref >= 0) {
506 t = abs_index(L, t);
507 lua_rawgeti(L, t, FREELIST_REF);
508 lua_rawseti(L, t, ref); /* t[ref] = t[FREELIST_REF] */
509 lua_pushinteger(L, ref);
510 lua_rawseti(L, t, FREELIST_REF); /* t[FREELIST_REF] = ref */
511 }
512}
513
514
515
516/*
517** {======================================================
518** Load functions
519** =======================================================
520*/
521
522typedef struct LoadF {
523 int extraline;
524 FILE *f;
525 char buff[LUAL_BUFFERSIZE];
526} LoadF;
527
528
529static const char *getF (lua_State *L, void *ud, size_t *size) {
530 LoadF *lf = (LoadF *)ud;
531 (void)L;
532 if (lf->extraline) {
533 lf->extraline = 0;
534 *size = 1;
535 return "\n";
536 }
537 if (feof(lf->f)) return NULL;
538 *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);
539 return (*size > 0) ? lf->buff : NULL;
540}
541
542
543static int errfile (lua_State *L, const char *what, int fnameindex) {
544 const char *serr = strerror(errno);
545 const char *filename = lua_tostring(L, fnameindex) + 1;
546 lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
547 lua_remove(L, fnameindex);
548 return LUA_ERRFILE;
549}
550
551
552LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {
553 LoadF lf;
554 int status, readstatus;
555 int c;
556 int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */
557 lf.extraline = 0;
558 if (filename == NULL) {
559 lua_pushliteral(L, "=stdin");
560 lf.f = stdin;
561 }
562 else {
563 lua_pushfstring(L, "@%s", filename);
564 lf.f = fopen(filename, "r");
565 if (lf.f == NULL) return errfile(L, "open", fnameindex);
566 }
567 c = getc(lf.f);
568 if (c == '#') { /* Unix exec. file? */
569 lf.extraline = 1;
570 while ((c = getc(lf.f)) != EOF && c != '\n') ; /* skip first line */
571 if (c == '\n') c = getc(lf.f);
572 }
573 if (c == LUA_SIGNATURE[0] && filename) { /* binary file? */
574 lf.f = freopen(filename, "rb", lf.f); /* reopen in binary mode */
575 if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
576 /* skip eventual `#!...' */
577 while ((c = getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;
578 lf.extraline = 0;
579 }
580 ungetc(c, lf.f);
581 status = lua_load(L, getF, &lf, lua_tostring(L, -1));
582 readstatus = ferror(lf.f);
583 if (filename) fclose(lf.f); /* close file (even in case of errors) */
584 if (readstatus) {
585 lua_settop(L, fnameindex); /* ignore results from `lua_load' */
586 return errfile(L, "read", fnameindex);
587 }
588 lua_remove(L, fnameindex);
589 return status;
590}
591
592
593typedef struct LoadS {
594 const char *s;
595 size_t size;
596} LoadS;
597
598
599static const char *getS (lua_State *L, void *ud, size_t *size) {
600 LoadS *ls = (LoadS *)ud;
601 (void)L;
602 if (ls->size == 0) return NULL;
603 *size = ls->size;
604 ls->size = 0;
605 return ls->s;
606}
607
608
609LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,
610 const char *name) {
611 LoadS ls;
612 ls.s = buff;
613 ls.size = size;
614 return lua_load(L, getS, &ls, name);
615}
616
617
618LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s) {
619 return luaL_loadbuffer(L, s, strlen(s), s);
620}
621
622
623
624/* }====================================================== */
625
626
627static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
628 (void)ud;
629 (void)osize;
630 if (nsize == 0) {
631 free(ptr);
632 return NULL;
633 }
634 else
635 return realloc(ptr, nsize);
636}
637
638
639static int panic (lua_State *L) {
640 (void)L; /* to avoid warnings */
641 fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n",
642 lua_tostring(L, -1));
643 return 0;
644}
645
646
647LUALIB_API lua_State *luaL_newstate (void) {
648 lua_State *L = lua_newstate(l_alloc, NULL);
649 if (L) lua_atpanic(L, &panic);
650 return L;
651}
652
diff --git a/libraries/LuaJIT-1.1.7/src/lauxlib.h b/libraries/LuaJIT-1.1.7/src/lauxlib.h
new file mode 100644
index 0000000..3425823
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lauxlib.h
@@ -0,0 +1,174 @@
1/*
2** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $
3** Auxiliary functions for building Lua libraries
4** See Copyright Notice in lua.h
5*/
6
7
8#ifndef lauxlib_h
9#define lauxlib_h
10
11
12#include <stddef.h>
13#include <stdio.h>
14
15#include "lua.h"
16
17
18#if defined(LUA_COMPAT_GETN)
19LUALIB_API int (luaL_getn) (lua_State *L, int t);
20LUALIB_API void (luaL_setn) (lua_State *L, int t, int n);
21#else
22#define luaL_getn(L,i) ((int)lua_objlen(L, i))
23#define luaL_setn(L,i,j) ((void)0) /* no op! */
24#endif
25
26#if defined(LUA_COMPAT_OPENLIB)
27#define luaI_openlib luaL_openlib
28#endif
29
30
31/* extra error code for `luaL_load' */
32#define LUA_ERRFILE (LUA_ERRERR+1)
33
34
35typedef struct luaL_Reg {
36 const char *name;
37 lua_CFunction func;
38} luaL_Reg;
39
40
41
42LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname,
43 const luaL_Reg *l, int nup);
44LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
45 const luaL_Reg *l);
46LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
47LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
48LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname);
49LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
50LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
51 size_t *l);
52LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
53 const char *def, size_t *l);
54LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
55LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
56
57LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
58LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
59 lua_Integer def);
60
61LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
62LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
63LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
64
65LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname);
66LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
67
68LUALIB_API void (luaL_where) (lua_State *L, int lvl);
69LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
70
71LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
72 const char *const lst[]);
73
74LUALIB_API int (luaL_ref) (lua_State *L, int t);
75LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
76
77LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);
78LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,
79 const char *name);
80LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
81
82LUALIB_API lua_State *(luaL_newstate) (void);
83
84
85LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
86 const char *r);
87
88LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,
89 const char *fname, int szhint);
90
91
92
93
94/*
95** ===============================================================
96** some useful macros
97** ===============================================================
98*/
99
100#define luaL_argcheck(L, cond,numarg,extramsg) \
101 ((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
102#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))
103#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))
104#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))
105#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d)))
106#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n)))
107#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d)))
108
109#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i)))
110
111#define luaL_dofile(L, fn) \
112 (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
113
114#define luaL_dostring(L, s) \
115 (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
116
117#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))
118
119#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
120
121/*
122** {======================================================
123** Generic Buffer manipulation
124** =======================================================
125*/
126
127
128
129typedef struct luaL_Buffer {
130 char *p; /* current position in buffer */
131 int lvl; /* number of strings in the stack (level) */
132 lua_State *L;
133 char buffer[LUAL_BUFFERSIZE];
134} luaL_Buffer;
135
136#define luaL_addchar(B,c) \
137 ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
138 (*(B)->p++ = (char)(c)))
139
140/* compatibility only */
141#define luaL_putchar(B,c) luaL_addchar(B,c)
142
143#define luaL_addsize(B,n) ((B)->p += (n))
144
145LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
146LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);
147LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
148LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
149LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
150LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
151
152
153/* }====================================================== */
154
155
156/* compatibility with ref system */
157
158/* pre-defined references */
159#define LUA_NOREF (-2)
160#define LUA_REFNIL (-1)
161
162#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
163 (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
164
165#define lua_unref(L,ref) luaL_unref(L, LUA_REGISTRYINDEX, (ref))
166
167#define lua_getref(L,ref) lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))
168
169
170#define luaL_reg luaL_Reg
171
172#endif
173
174
diff --git a/libraries/LuaJIT-1.1.7/src/lbaselib.c b/libraries/LuaJIT-1.1.7/src/lbaselib.c
new file mode 100644
index 0000000..2366a02
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lbaselib.c
@@ -0,0 +1,679 @@
1/*
2** $Id: lbaselib.c,v 1.191.1.6 2008/02/14 16:46:22 roberto Exp $
3** Basic library
4** See Copyright Notice in lua.h
5*/
6
7
8
9#include <ctype.h>
10#include <stdio.h>
11#include <stdlib.h>
12#include <string.h>
13
14#define lbaselib_c
15#define LUA_LIB
16
17#include "lua.h"
18
19#include "lauxlib.h"
20#include "lualib.h"
21#ifndef COCO_DISABLE
22#include "lcoco.h"
23#endif
24
25
26
27
28/*
29** If your system does not support `stdout', you can just remove this function.
30** If you need, you can define your own `print' function, following this
31** model but changing `fputs' to put the strings at a proper place
32** (a console window or a log file, for instance).
33*/
34static int luaB_print (lua_State *L) {
35 int n = lua_gettop(L); /* number of arguments */
36 int i;
37 lua_getglobal(L, "tostring");
38 for (i=1; i<=n; i++) {
39 const char *s;
40 lua_pushvalue(L, -1); /* function to be called */
41 lua_pushvalue(L, i); /* value to print */
42 lua_call(L, 1, 1);
43 s = lua_tostring(L, -1); /* get result */
44 if (s == NULL)
45 return luaL_error(L, LUA_QL("tostring") " must return a string to "
46 LUA_QL("print"));
47 if (i>1) fputs("\t", stdout);
48 fputs(s, stdout);
49 lua_pop(L, 1); /* pop result */
50 }
51 fputs("\n", stdout);
52 return 0;
53}
54
55
56static int luaB_tonumber (lua_State *L) {
57 int base = luaL_optint(L, 2, 10);
58 if (base == 10) { /* standard conversion */
59 luaL_checkany(L, 1);
60 if (lua_isnumber(L, 1)) {
61 lua_pushnumber(L, lua_tonumber(L, 1));
62 return 1;
63 }
64 }
65 else {
66 const char *s1 = luaL_checkstring(L, 1);
67 char *s2;
68 unsigned long n;
69 luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
70 n = strtoul(s1, &s2, base);
71 if (s1 != s2) { /* at least one valid digit? */
72 while (isspace((unsigned char)(*s2))) s2++; /* skip trailing spaces */
73 if (*s2 == '\0') { /* no invalid trailing characters? */
74 lua_pushnumber(L, (lua_Number)n);
75 return 1;
76 }
77 }
78 }
79 lua_pushnil(L); /* else not a number */
80 return 1;
81}
82
83
84static int luaB_error (lua_State *L) {
85 int level = luaL_optint(L, 2, 1);
86 lua_settop(L, 1);
87 if (lua_isstring(L, 1) && level > 0) { /* add extra information? */
88 luaL_where(L, level);
89 lua_pushvalue(L, 1);
90 lua_concat(L, 2);
91 }
92 return lua_error(L);
93}
94
95
96static int luaB_getmetatable (lua_State *L) {
97 luaL_checkany(L, 1);
98 if (!lua_getmetatable(L, 1)) {
99 lua_pushnil(L);
100 return 1; /* no metatable */
101 }
102 luaL_getmetafield(L, 1, "__metatable");
103 return 1; /* returns either __metatable field (if present) or metatable */
104}
105
106
107static int luaB_setmetatable (lua_State *L) {
108 int t = lua_type(L, 2);
109 luaL_checktype(L, 1, LUA_TTABLE);
110 luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
111 "nil or table expected");
112 if (luaL_getmetafield(L, 1, "__metatable"))
113 luaL_error(L, "cannot change a protected metatable");
114 lua_settop(L, 2);
115 lua_setmetatable(L, 1);
116 return 1;
117}
118
119
120static void getfunc (lua_State *L, int opt) {
121 if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);
122 else {
123 lua_Debug ar;
124 int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);
125 luaL_argcheck(L, level >= 0, 1, "level must be non-negative");
126 if (lua_getstack(L, level, &ar) == 0)
127 luaL_argerror(L, 1, "invalid level");
128 lua_getinfo(L, "f", &ar);
129 if (lua_isnil(L, -1))
130 luaL_error(L, "no function environment for tail call at level %d",
131 level);
132 }
133}
134
135
136static int luaB_getfenv (lua_State *L) {
137 getfunc(L, 1);
138 if (lua_iscfunction(L, -1)) /* is a C function? */
139 lua_pushvalue(L, LUA_GLOBALSINDEX); /* return the thread's global env. */
140 else
141 lua_getfenv(L, -1);
142 return 1;
143}
144
145
146static int luaB_setfenv (lua_State *L) {
147 luaL_checktype(L, 2, LUA_TTABLE);
148 getfunc(L, 0);
149 lua_pushvalue(L, 2);
150 if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
151 /* change environment of current thread */
152 lua_pushthread(L);
153 lua_insert(L, -2);
154 lua_setfenv(L, -2);
155 return 0;
156 }
157 else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
158 luaL_error(L,
159 LUA_QL("setfenv") " cannot change environment of given object");
160 return 1;
161}
162
163
164static int luaB_rawequal (lua_State *L) {
165 luaL_checkany(L, 1);
166 luaL_checkany(L, 2);
167 lua_pushboolean(L, lua_rawequal(L, 1, 2));
168 return 1;
169}
170
171
172static int luaB_rawget (lua_State *L) {
173 luaL_checktype(L, 1, LUA_TTABLE);
174 luaL_checkany(L, 2);
175 lua_settop(L, 2);
176 lua_rawget(L, 1);
177 return 1;
178}
179
180static int luaB_rawset (lua_State *L) {
181 luaL_checktype(L, 1, LUA_TTABLE);
182 luaL_checkany(L, 2);
183 luaL_checkany(L, 3);
184 lua_settop(L, 3);
185 lua_rawset(L, 1);
186 return 1;
187}
188
189
190static int luaB_gcinfo (lua_State *L) {
191 lua_pushinteger(L, lua_getgccount(L));
192 return 1;
193}
194
195
196static int luaB_collectgarbage (lua_State *L) {
197 static const char *const opts[] = {"stop", "restart", "collect",
198 "count", "step", "setpause", "setstepmul", NULL};
199 static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
200 LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
201 int o = luaL_checkoption(L, 1, "collect", opts);
202 int ex = luaL_optint(L, 2, 0);
203 int res = lua_gc(L, optsnum[o], ex);
204 switch (optsnum[o]) {
205 case LUA_GCCOUNT: {
206 int b = lua_gc(L, LUA_GCCOUNTB, 0);
207 lua_pushnumber(L, res + ((lua_Number)b/1024));
208 return 1;
209 }
210 case LUA_GCSTEP: {
211 lua_pushboolean(L, res);
212 return 1;
213 }
214 default: {
215 lua_pushnumber(L, res);
216 return 1;
217 }
218 }
219}
220
221
222static int luaB_type (lua_State *L) {
223 luaL_checkany(L, 1);
224 lua_pushstring(L, luaL_typename(L, 1));
225 return 1;
226}
227
228
229static int luaB_next (lua_State *L) {
230 luaL_checktype(L, 1, LUA_TTABLE);
231 lua_settop(L, 2); /* create a 2nd argument if there isn't one */
232 if (lua_next(L, 1))
233 return 2;
234 else {
235 lua_pushnil(L);
236 return 1;
237 }
238}
239
240
241static int luaB_pairs (lua_State *L) {
242 luaL_checktype(L, 1, LUA_TTABLE);
243 lua_pushvalue(L, lua_upvalueindex(1)); /* return generator, */
244 lua_pushvalue(L, 1); /* state, */
245 lua_pushnil(L); /* and initial value */
246 return 3;
247}
248
249
250static int ipairsaux (lua_State *L) {
251 int i = luaL_checkint(L, 2);
252 luaL_checktype(L, 1, LUA_TTABLE);
253 i++; /* next value */
254 lua_pushinteger(L, i);
255 lua_rawgeti(L, 1, i);
256 return (lua_isnil(L, -1)) ? 0 : 2;
257}
258
259
260static int luaB_ipairs (lua_State *L) {
261 luaL_checktype(L, 1, LUA_TTABLE);
262 lua_pushvalue(L, lua_upvalueindex(1)); /* return generator, */
263 lua_pushvalue(L, 1); /* state, */
264 lua_pushinteger(L, 0); /* and initial value */
265 return 3;
266}
267
268
269static int load_aux (lua_State *L, int status) {
270 if (status == 0) /* OK? */
271 return 1;
272 else {
273 lua_pushnil(L);
274 lua_insert(L, -2); /* put before error message */
275 return 2; /* return nil plus error message */
276 }
277}
278
279
280static int luaB_loadstring (lua_State *L) {
281 size_t l;
282 const char *s = luaL_checklstring(L, 1, &l);
283 const char *chunkname = luaL_optstring(L, 2, s);
284 return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
285}
286
287
288static int luaB_loadfile (lua_State *L) {
289 const char *fname = luaL_optstring(L, 1, NULL);
290 return load_aux(L, luaL_loadfile(L, fname));
291}
292
293
294/*
295** Reader for generic `load' function: `lua_load' uses the
296** stack for internal stuff, so the reader cannot change the
297** stack top. Instead, it keeps its resulting string in a
298** reserved slot inside the stack.
299*/
300static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
301 (void)ud; /* to avoid warnings */
302 luaL_checkstack(L, 2, "too many nested functions");
303 lua_pushvalue(L, 1); /* get function */
304 lua_call(L, 0, 1); /* call it */
305 if (lua_isnil(L, -1)) {
306 *size = 0;
307 return NULL;
308 }
309 else if (lua_isstring(L, -1)) {
310 lua_replace(L, 3); /* save string in a reserved stack slot */
311 return lua_tolstring(L, 3, size);
312 }
313 else luaL_error(L, "reader function must return a string");
314 return NULL; /* to avoid warnings */
315}
316
317
318static int luaB_load (lua_State *L) {
319 int status;
320 const char *cname = luaL_optstring(L, 2, "=(load)");
321 luaL_checktype(L, 1, LUA_TFUNCTION);
322 lua_settop(L, 3); /* function, eventual name, plus one reserved slot */
323 status = lua_load(L, generic_reader, NULL, cname);
324 return load_aux(L, status);
325}
326
327
328static int luaB_dofile (lua_State *L) {
329 const char *fname = luaL_optstring(L, 1, NULL);
330 int n = lua_gettop(L);
331 if (luaL_loadfile(L, fname) != 0) lua_error(L);
332 lua_call(L, 0, LUA_MULTRET);
333 return lua_gettop(L) - n;
334}
335
336
337static int luaB_assert (lua_State *L) {
338 luaL_checkany(L, 1);
339 if (!lua_toboolean(L, 1))
340 return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
341 return lua_gettop(L);
342}
343
344
345static int luaB_unpack (lua_State *L) {
346 int i, e, n;
347 luaL_checktype(L, 1, LUA_TTABLE);
348 i = luaL_optint(L, 2, 1);
349 e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
350 if (i > e) return 0; /* empty range */
351 n = e - i + 1; /* number of elements */
352 if (n <= 0 || !lua_checkstack(L, n)) /* n <= 0 means arith. overflow */
353 return luaL_error(L, "too many results to unpack");
354 lua_rawgeti(L, 1, i); /* push arg[i] (avoiding overflow problems) */
355 while (i++ < e) /* push arg[i + 1...e] */
356 lua_rawgeti(L, 1, i);
357 return n;
358}
359
360
361static int luaB_select (lua_State *L) {
362 int n = lua_gettop(L);
363 if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
364 lua_pushinteger(L, n-1);
365 return 1;
366 }
367 else {
368 int i = luaL_checkint(L, 1);
369 if (i < 0) i = n + i;
370 else if (i > n) i = n;
371 luaL_argcheck(L, 1 <= i, 1, "index out of range");
372 return n - i;
373 }
374}
375
376
377static int luaB_pcall (lua_State *L) {
378 int status;
379 luaL_checkany(L, 1);
380 status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
381 lua_pushboolean(L, (status == 0));
382 lua_insert(L, 1);
383 return lua_gettop(L); /* return status + all results */
384}
385
386
387static int luaB_xpcall (lua_State *L) {
388 int status;
389 luaL_checkany(L, 2);
390 lua_settop(L, 2);
391 lua_insert(L, 1); /* put error function under function to be called */
392 status = lua_pcall(L, 0, LUA_MULTRET, 1);
393 lua_pushboolean(L, (status == 0));
394 lua_replace(L, 1);
395 return lua_gettop(L); /* return status + all results */
396}
397
398
399static int luaB_tostring (lua_State *L) {
400 luaL_checkany(L, 1);
401 if (luaL_callmeta(L, 1, "__tostring")) /* is there a metafield? */
402 return 1; /* use its value */
403 switch (lua_type(L, 1)) {
404 case LUA_TNUMBER:
405 lua_pushstring(L, lua_tostring(L, 1));
406 break;
407 case LUA_TSTRING:
408 lua_pushvalue(L, 1);
409 break;
410 case LUA_TBOOLEAN:
411 lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
412 break;
413 case LUA_TNIL:
414 lua_pushliteral(L, "nil");
415 break;
416 default:
417 lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));
418 break;
419 }
420 return 1;
421}
422
423
424static int luaB_newproxy (lua_State *L) {
425 lua_settop(L, 1);
426 lua_newuserdata(L, 0); /* create proxy */
427 if (lua_toboolean(L, 1) == 0)
428 return 1; /* no metatable */
429 else if (lua_isboolean(L, 1)) {
430 lua_newtable(L); /* create a new metatable `m' ... */
431 lua_pushvalue(L, -1); /* ... and mark `m' as a valid metatable */
432 lua_pushboolean(L, 1);
433 lua_rawset(L, lua_upvalueindex(1)); /* weaktable[m] = true */
434 }
435 else {
436 int validproxy = 0; /* to check if weaktable[metatable(u)] == true */
437 if (lua_getmetatable(L, 1)) {
438 lua_rawget(L, lua_upvalueindex(1));
439 validproxy = lua_toboolean(L, -1);
440 lua_pop(L, 1); /* remove value */
441 }
442 luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
443 lua_getmetatable(L, 1); /* metatable is valid; get it */
444 }
445 lua_setmetatable(L, 2);
446 return 1;
447}
448
449
450static const luaL_Reg base_funcs[] = {
451 {"assert", luaB_assert},
452 {"collectgarbage", luaB_collectgarbage},
453 {"dofile", luaB_dofile},
454 {"error", luaB_error},
455 {"gcinfo", luaB_gcinfo},
456 {"getfenv", luaB_getfenv},
457 {"getmetatable", luaB_getmetatable},
458 {"loadfile", luaB_loadfile},
459 {"load", luaB_load},
460 {"loadstring", luaB_loadstring},
461 {"next", luaB_next},
462 {"pcall", luaB_pcall},
463 {"print", luaB_print},
464 {"rawequal", luaB_rawequal},
465 {"rawget", luaB_rawget},
466 {"rawset", luaB_rawset},
467 {"select", luaB_select},
468 {"setfenv", luaB_setfenv},
469 {"setmetatable", luaB_setmetatable},
470 {"tonumber", luaB_tonumber},
471 {"tostring", luaB_tostring},
472 {"type", luaB_type},
473 {"unpack", luaB_unpack},
474 {"xpcall", luaB_xpcall},
475 {NULL, NULL}
476};
477
478
479/*
480** {======================================================
481** Coroutine library
482** =======================================================
483*/
484
485#define CO_RUN 0 /* running */
486#define CO_SUS 1 /* suspended */
487#define CO_NOR 2 /* 'normal' (it resumed another coroutine) */
488#define CO_DEAD 3
489
490static const char *const statnames[] =
491 {"running", "suspended", "normal", "dead"};
492
493static int costatus (lua_State *L, lua_State *co) {
494 if (L == co) return CO_RUN;
495 switch (lua_status(co)) {
496 case LUA_YIELD:
497 return CO_SUS;
498 case 0: {
499 lua_Debug ar;
500 if (lua_getstack(co, 0, &ar) > 0) /* does it have frames? */
501 return CO_NOR; /* it is running */
502 else if (lua_gettop(co) == 0)
503 return CO_DEAD;
504 else
505 return CO_SUS; /* initial state */
506 }
507 default: /* some error occured */
508 return CO_DEAD;
509 }
510}
511
512
513static int luaB_costatus (lua_State *L) {
514 lua_State *co = lua_tothread(L, 1);
515 luaL_argcheck(L, co, 1, "coroutine expected");
516 lua_pushstring(L, statnames[costatus(L, co)]);
517 return 1;
518}
519
520
521static int auxresume (lua_State *L, lua_State *co, int narg) {
522 int status = costatus(L, co);
523 if (!lua_checkstack(co, narg))
524 luaL_error(L, "too many arguments to resume");
525 if (status != CO_SUS) {
526 lua_pushfstring(L, "cannot resume %s coroutine", statnames[status]);
527 return -1; /* error flag */
528 }
529 lua_xmove(L, co, narg);
530 status = lua_resume(co, narg);
531 if (status == 0 || status == LUA_YIELD) {
532 int nres = lua_gettop(co);
533 if (!lua_checkstack(L, nres + 1))
534 luaL_error(L, "too many results to resume");
535 lua_xmove(co, L, nres); /* move yielded values */
536 return nres;
537 }
538 else {
539 lua_xmove(co, L, 1); /* move error message */
540 return -1; /* error flag */
541 }
542}
543
544
545static int luaB_coresume (lua_State *L) {
546 lua_State *co = lua_tothread(L, 1);
547 int r;
548 luaL_argcheck(L, co, 1, "coroutine expected");
549 r = auxresume(L, co, lua_gettop(L) - 1);
550 if (r < 0) {
551 lua_pushboolean(L, 0);
552 lua_insert(L, -2);
553 return 2; /* return false + error message */
554 }
555 else {
556 lua_pushboolean(L, 1);
557 lua_insert(L, -(r + 1));
558 return r + 1; /* return true + `resume' returns */
559 }
560}
561
562
563static int luaB_auxwrap (lua_State *L) {
564 lua_State *co = lua_tothread(L, lua_upvalueindex(1));
565 int r = auxresume(L, co, lua_gettop(L));
566 if (r < 0) {
567 if (lua_isstring(L, -1)) { /* error object is a string? */
568 luaL_where(L, 1); /* add extra info */
569 lua_insert(L, -2);
570 lua_concat(L, 2);
571 }
572 lua_error(L); /* propagate error */
573 }
574 return r;
575}
576
577
578#ifndef COCO_DISABLE
579static int luaB_cstacksize (lua_State *L)
580{
581 lua_pushinteger(L, luaCOCO_cstacksize(luaL_optint(L, 1, -1)));
582 return 1;
583}
584#endif
585
586
587static int luaB_cocreate (lua_State *L) {
588#ifdef COCO_DISABLE
589 lua_State *NL = lua_newthread(L);
590 luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,
591 "Lua function expected");
592#else
593 int cstacksize = luaL_optint(L, 2, 0);
594 lua_State *NL = lua_newcthread(L, cstacksize);
595 luaL_argcheck(L, lua_isfunction(L, 1) &&
596 (cstacksize >= 0 ? 1 : !lua_iscfunction(L, 1)),
597 1, "Lua function expected");
598#endif
599 lua_pushvalue(L, 1); /* move function to top */
600 lua_xmove(L, NL, 1); /* move function from L to NL */
601 return 1;
602}
603
604
605static int luaB_cowrap (lua_State *L) {
606 luaB_cocreate(L);
607 lua_pushcclosure(L, luaB_auxwrap, 1);
608 return 1;
609}
610
611
612static int luaB_yield (lua_State *L) {
613 return lua_yield(L, lua_gettop(L));
614}
615
616
617static int luaB_corunning (lua_State *L) {
618 if (lua_pushthread(L))
619 lua_pushnil(L); /* main thread is not a coroutine */
620 return 1;
621}
622
623
624static const luaL_Reg co_funcs[] = {
625 {"create", luaB_cocreate},
626 {"resume", luaB_coresume},
627 {"running", luaB_corunning},
628 {"status", luaB_costatus},
629 {"wrap", luaB_cowrap},
630 {"yield", luaB_yield},
631#ifndef COCO_DISABLE
632 {"cstacksize", luaB_cstacksize},
633#endif
634 {NULL, NULL}
635};
636
637/* }====================================================== */
638
639
640static void auxopen (lua_State *L, const char *name,
641 lua_CFunction f, lua_CFunction u) {
642 lua_pushcfunction(L, u);
643 lua_pushcclosure(L, f, 1);
644 lua_setfield(L, -2, name);
645}
646
647
648static void base_open (lua_State *L) {
649 /* set global _G */
650 lua_pushvalue(L, LUA_GLOBALSINDEX);
651 lua_setglobal(L, "_G");
652 /* open lib into global table */
653 luaL_register(L, "_G", base_funcs);
654 lua_pushliteral(L, LUA_VERSION);
655 lua_setglobal(L, "_VERSION"); /* set global _VERSION */
656 /* `ipairs' and `pairs' need auxliliary functions as upvalues */
657 auxopen(L, "ipairs", luaB_ipairs, ipairsaux);
658 auxopen(L, "pairs", luaB_pairs, luaB_next);
659 /* `newproxy' needs a weaktable as upvalue */
660 lua_createtable(L, 0, 1); /* new table `w' */
661 lua_pushvalue(L, -1); /* `w' will be its own metatable */
662 lua_setmetatable(L, -2);
663 lua_pushliteral(L, "kv");
664 lua_setfield(L, -2, "__mode"); /* metatable(w).__mode = "kv" */
665 lua_pushcclosure(L, luaB_newproxy, 1);
666 lua_setglobal(L, "newproxy"); /* set global `newproxy' */
667}
668
669
670LUALIB_API int luaopen_base (lua_State *L) {
671 base_open(L);
672 luaL_register(L, LUA_COLIBNAME, co_funcs);
673#ifndef COCO_DISABLE
674 lua_pushboolean(L, 1);
675 lua_setfield(L, -2, "coco");
676#endif
677 return 2;
678}
679
diff --git a/libraries/LuaJIT-1.1.7/src/lcoco.c b/libraries/LuaJIT-1.1.7/src/lcoco.c
new file mode 100644
index 0000000..c3acc68
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lcoco.c
@@ -0,0 +1,693 @@
1/*
2** Copyright (C) 2004-2011 Mike Pall. All rights reserved.
3**
4** Permission is hereby granted, free of charge, to any person obtaining
5** a copy of this software and associated documentation files (the
6** "Software"), to deal in the Software without restriction, including
7** without limitation the rights to use, copy, modify, merge, publish,
8** distribute, sublicense, and/or sell copies of the Software, and to
9** permit persons to whom the Software is furnished to do so, subject to
10** the following conditions:
11**
12** The above copyright notice and this permission notice shall be
13** included in all copies or substantial portions of the Software.
14**
15** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
19** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
20** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
21** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22**
23** [ MIT license: http://www.opensource.org/licenses/mit-license.php ]
24*/
25
26/* Coco -- True C coroutines for Lua. http://luajit.org/coco.html */
27#ifndef COCO_DISABLE
28
29#define lcoco_c
30#define LUA_CORE
31
32#include "lua.h"
33
34#include "lobject.h"
35#include "lstate.h"
36#include "ldo.h"
37#include "lvm.h"
38#include "lgc.h"
39
40
41/*
42** Define this if you want to run Coco with valgrind. You will get random
43** errors about accessing memory from newly allocated C stacks if you don't.
44** You need at least valgrind 3.0 for this to work.
45**
46** This macro evaluates to a no-op if not run with valgrind. I.e. you can
47** use the same binary for regular runs, too (without a performance loss).
48*/
49#ifdef USE_VALGRIND
50#include <valgrind/valgrind.h>
51#define STACK_REG(coco, p, sz) (coco)->vgid = VALGRIND_STACK_REGISTER(p, p+sz);
52#define STACK_DEREG(coco) VALGRIND_STACK_DEREGISTER((coco)->vgid);
53#define STACK_VGID unsigned int vgid;
54#else
55#define STACK_REG(coco, p, sz)
56#define STACK_DEREG(id)
57#define STACK_VGID
58#endif
59
60/* ------------------------------------------------------------------------ */
61
62/* Use Windows Fibers. */
63#if defined(COCO_USE_FIBERS)
64
65#define _WIN32_WINNT 0x0400
66#include <windows.h>
67
68#define COCO_MAIN_DECL CALLBACK
69
70typedef LPFIBER_START_ROUTINE coco_MainFunc;
71
72#define COCO_NEW(OL, NL, cstacksize, mainfunc) \
73 if ((L2COCO(NL)->fib = CreateFiber(cstacksize, mainfunc, NL)) == NULL) \
74 luaD_throw(OL, LUA_ERRMEM);
75
76#define COCO_FREE(L) \
77 DeleteFiber(L2COCO(L)->fib); \
78 L2COCO(L)->fib = NULL;
79
80/* See: http://blogs.msdn.com/oldnewthing/archive/2004/12/31/344799.aspx */
81#define COCO_JUMPIN(coco) \
82 { void *cur = GetCurrentFiber(); \
83 coco->back = (cur == NULL || cur == (void *)0x1e00) ? \
84 ConvertThreadToFiber(NULL) : cur; } \
85 SwitchToFiber(coco->fib);
86
87#define COCO_JUMPOUT(coco) \
88 SwitchToFiber(coco->back);
89
90/* CreateFiber() defaults to STACKSIZE from the Windows module .def file. */
91#define COCO_DEFAULT_CSTACKSIZE 0
92
93/* ------------------------------------------------------------------------ */
94
95#else /* !COCO_USE_FIBERS */
96
97#ifndef COCO_USE_UCONTEXT
98
99/* Try inline asm first. */
100#if __GNUC__ >= 3 && !defined(COCO_USE_SETJMP)
101
102#if defined(__i386) || defined(__i386__)
103
104#ifdef __PIC__
105typedef void *coco_ctx[4]; /* eip, esp, ebp, ebx */
106static inline void coco_switch(coco_ctx from, coco_ctx to)
107{
108 __asm__ __volatile__ (
109 "call 1f\n" "1:\tpopl %%eax\n\t" "addl $(2f-1b),%%eax\n\t"
110 "movl %%eax, (%0)\n\t" "movl %%esp, 4(%0)\n\t"
111 "movl %%ebp, 8(%0)\n\t" "movl %%ebx, 12(%0)\n\t"
112 "movl 12(%1), %%ebx\n\t" "movl 8(%1), %%ebp\n\t"
113 "movl 4(%1), %%esp\n\t" "jmp *(%1)\n" "2:\n"
114 : "+S" (from), "+D" (to) : : "eax", "ecx", "edx", "memory", "cc");
115}
116#else
117typedef void *coco_ctx[3]; /* eip, esp, ebp */
118static inline void coco_switch(coco_ctx from, coco_ctx to)
119{
120 __asm__ __volatile__ (
121 "movl $1f, (%0)\n\t" "movl %%esp, 4(%0)\n\t" "movl %%ebp, 8(%0)\n\t"
122 "movl 8(%1), %%ebp\n\t" "movl 4(%1), %%esp\n\t" "jmp *(%1)\n" "1:\n"
123 : "+S" (from), "+D" (to) : : "eax", "ebx", "ecx", "edx", "memory", "cc");
124}
125#endif
126
127#define COCO_CTX coco_ctx
128#define COCO_SWITCH(from, to) coco_switch(from, to);
129#define COCO_MAKECTX(coco, buf, func, stack, a0) \
130 buf[0] = (void *)(func); \
131 buf[1] = (void *)(stack); \
132 buf[2] = (void *)0; \
133 stack[0] = 0xdeadc0c0; /* Dummy return address. */ \
134 coco->arg0 = (size_t)(a0);
135#define COCO_STATE_HEAD size_t arg0;
136
137#elif defined(__x86_64__)
138
139static void coco_wrap_main(void)
140{
141 __asm__ __volatile__ ("\tmovq %r13, %rdi\n\tjmpq *%r12\n");
142}
143
144typedef void *coco_ctx[8]; /* rip, rsp, rbp, rbx, r12, r13, r14, r15 */
145static inline void coco_switch(coco_ctx from, coco_ctx to)
146{
147 __asm__ __volatile__ (
148 "leaq 1f(%%rip), %%rax\n\t"
149 "movq %%rax, (%0)\n\t" "movq %%rsp, 8(%0)\n\t" "movq %%rbp, 16(%0)\n\t"
150 "movq %%rbx, 24(%0)\n\t" "movq %%r12, 32(%0)\n\t" "movq %%r13, 40(%0)\n\t"
151 "movq %%r14, 48(%0)\n\t" "movq %%r15, 56(%0)\n\t"
152 "movq 56(%1), %%r15\n\t" "movq 48(%1), %%r14\n\t" "movq 40(%1), %%r13\n\t"
153 "movq 32(%1), %%r12\n\t" "movq 24(%1), %%rbx\n\t" "movq 16(%1), %%rbp\n\t"
154 "movq 8(%1), %%rsp\n\t" "jmpq *(%1)\n" "1:\n"
155 : "+S" (from), "+D" (to) :
156 : "rax", "rcx", "rdx", "r8", "r9", "r10", "r11", "memory", "cc");
157}
158
159#define COCO_CTX coco_ctx
160#define COCO_SWITCH(from, to) coco_switch(from, to);
161#define COCO_MAKECTX(coco, buf, func, stack, a0) \
162 buf[0] = (void *)(coco_wrap_main); \
163 buf[1] = (void *)(stack); \
164 buf[2] = (void *)0; \
165 buf[3] = (void *)0; \
166 buf[4] = (void *)(func); \
167 buf[5] = (void *)(a0); \
168 buf[6] = (void *)0; \
169 buf[7] = (void *)0; \
170 stack[0] = 0xdeadc0c0deadc0c0; /* Dummy return address. */ \
171
172#elif __mips && _MIPS_SIM == _MIPS_SIM_ABI32 && !defined(__mips_eabi)
173
174/* No way to avoid the function prologue with inline assembler. So use this: */
175static const unsigned int coco_switch[] = {
176#ifdef __mips_soft_float
177#define COCO_STACKSAVE -10
178 0x27bdffd8, /* addiu sp, sp, -(10*4) */
179#else
180#define COCO_STACKSAVE -22
181 0x27bdffa8, /* addiu sp, sp, -(10*4+6*8) */
182 /* sdc1 {$f20-$f30}, offset(sp) */
183 0xf7be0050, 0xf7bc0048, 0xf7ba0040, 0xf7b80038, 0xf7b60030, 0xf7b40028,
184#endif
185 /* sw {gp,s0-s8}, offset(sp) */
186 0xafbe0024, 0xafb70020, 0xafb6001c, 0xafb50018, 0xafb40014, 0xafb30010,
187 0xafb2000c, 0xafb10008, 0xafb00004, 0xafbc0000,
188 /* sw sp, 4(a0); sw ra, 0(a0); lw ra, 0(a1); lw sp, 4(a1); move t9, ra */
189 0xac9d0004, 0xac9f0000, 0x8cbf0000, 0x8cbd0004, 0x03e0c821,
190 /* lw caller-saved-reg, offset(sp) */
191 0x8fbe0024, 0x8fb70020, 0x8fb6001c, 0x8fb50018, 0x8fb40014, 0x8fb30010,
192 0x8fb2000c, 0x8fb10008, 0x8fb00004, 0x8fbc0000,
193#ifdef __mips_soft_float
194 0x03e00008, 0x27bd0028 /* jr ra; addiu sp, sp, 10*4 */
195#else
196 /* ldc1 {$f20-$f30}, offset(sp) */
197 0xd7be0050, 0xd7bc0048, 0xd7ba0040, 0xd7b80038, 0xd7b60030, 0xd7b40028,
198 0x03e00008, 0x27bd0058 /* jr ra; addiu sp, sp, 10*4+6*8 */
199#endif
200};
201
202typedef void *coco_ctx[2]; /* ra, sp */
203#define COCO_CTX coco_ctx
204#define COCO_SWITCH(from, to) \
205 ((void (*)(coco_ctx, coco_ctx))coco_switch)(from, to);
206#define COCO_MAKECTX(coco, buf, func, stack, a0) \
207 buf[0] = (void *)(func); \
208 buf[1] = (void *)&stack[COCO_STACKSAVE]; \
209 stack[4] = (size_t)(a0); /* Assumes o32 ABI. */
210#define COCO_STACKADJUST 8
211#define COCO_MAIN_PARAM int _a, int _b, int _c, int _d, lua_State *L
212
213#elif defined(__sparc__)
214
215typedef void *coco_ctx[4];
216#define COCO_CTX coco_ctx
217#define COCO_SWITCH(from, to) coco_switch(from, to);
218#define COCO_STACKADJUST 24
219
220#if defined(__LP64__)
221#define COCO_STACKBIAS (2047UL)
222#define COCO_PTR2SP(stack) (((unsigned long)stack)-COCO_STACKBIAS)
223static inline void coco_switch(coco_ctx from, coco_ctx to)
224{
225 void *__stack[16] __attribute__((aligned (16)));
226 unsigned long __tmp_sp = COCO_PTR2SP(__stack);
227 __asm__ __volatile__
228 (/* Flush register window(s) to stack and save the previous stack
229 pointer to capture the current registers, %l0-%l7 and %i0-%i7. */
230 "ta 3\n\t"
231 "stx %%sp,[%0+8]\n\t"
232 /* Move to a temporary stack. If the register window is flushed
233 for some reason (e.g. context switch), not the next stack
234 but the temporary stack should be used so as not to break
235 neither the previous nor next stack */
236 "mov %2,%%sp\n\t"
237 "sethi %%hh(1f),%%g1\n\t" /* i.e. setx 1f,%%g1 */
238 "or %%g1,%%hm(1f),%%g1\n\t"
239 "sethi %%lm(1f),%%g2\n\t"
240 "or %%g2,%%lo(1f),%%g2\n\t"
241 "sllx %%g1,32,%%g1\n\t"
242 "or %%g1,%%g2,%%g1\n\t"
243 "stx %%g1,[%0]\n\t"
244 /* Restore registers from stack. DO NOT load the next stack
245 pointer directly to %sp. The register window can be possibly
246 flushed and restored asynchronous (e.g. context switch). */
247 "mov %1,%%o1\n\t"
248 "ldx [%%o1+8],%%o2\n\t"
249 "ldx [%%o2+%3],%%l0\n\t"
250 "ldx [%%o2+%3+8],%%l1\n\t"
251 "ldx [%%o2+%3+0x10],%%l2\n\t"
252 "ldx [%%o2+%3+0x18],%%l3\n\t"
253 "ldx [%%o2+%3+0x20],%%l4\n\t"
254 "ldx [%%o2+%3+0x28],%%l5\n\t"
255 "ldx [%%o2+%3+0x30],%%l6\n\t"
256 "ldx [%%o2+%3+0x38],%%l7\n\t"
257 "ldx [%%o2+%3+0x40],%%i0\n\t"
258 "ldx [%%o2+%3+0x48],%%i1\n\t"
259 "ldx [%%o2+%3+0x50],%%i2\n\t"
260 "ldx [%%o2+%3+0x58],%%i3\n\t"
261 "ldx [%%o2+%3+0x60],%%i4\n\t"
262 "ldx [%%o2+%3+0x68],%%i5\n\t"
263 "ldx [%%o2+%3+0x70],%%i6\n\t"
264 "ldx [%%o2+%3+0x78],%%i7\n\t"
265 /* Move to the next stack with the consistent registers atomically */
266 "mov %%o2,%%sp\n\t"
267 "ldx [%%o1],%%o2\n\t"
268 /* Since %o0-%o7 are marked as clobbered, values are safely overwritten
269 across the inline assembly. %o0-%o7 will have meaningless values
270 after leaving the inline assembly. The only exception is %o0, which
271 serves as an argument to coco_main */
272 "ldx [%%o1+16],%%o0\n\t"
273 "jmpl %%o2,%%g0\n\t"
274 "nop\n\t"
275 "1:\n"
276 /* An assumption is made here; no input operand is assigned to %g1
277 nor %g2. It's the case for the currently avilable gcc's */
278 : : "r"(from),"r"(to),"r"(__tmp_sp),"i"(COCO_STACKBIAS)
279 : "g1","g2","o0","o1","o2","o3","o4","o5","o7","memory","cc");
280}
281
282#define COCO_MAKECTX(coco, buf, func, stack, a0) \
283 buf[0] = (void *)(func); \
284 buf[1] = (void *)COCO_PTR2SP(&(stack)[0]); \
285 buf[2] = (void *)(a0); \
286 stack[0] = 0; \
287 stack[1] = 0; \
288 stack[2] = 0; \
289 stack[3] = 0; \
290 stack[4] = 0; \
291 stack[5] = 0; \
292 stack[6] = 0; \
293 stack[7] = 0; \
294 stack[8] = 0; \
295 stack[9] = 0; \
296 stack[10] = 0; \
297 stack[11] = 0; \
298 stack[12] = 0; \
299 stack[13] = 0; \
300 stack[14] = COCO_PTR2SP(&(stack)[COCO_STACKADJUST]); \
301 stack[15] = 0xdeadc0c0deadc0c0; /* Dummy return address. */ \
302
303#else
304static inline void coco_switch(coco_ctx from, coco_ctx to)
305{
306 void *__tmp_stack[16] __attribute__((aligned (16)));
307 __asm__ __volatile__
308 ("ta 3\n\t"
309 "st %%sp,[%0+4]\n\t"
310 "mov %2,%%sp\n\t"
311 "set 1f,%%g1\n\t"
312 "st %%g1,[%0]\n\t"
313 "mov %1,%%o1\n\t"
314 "ld [%%o1+4],%%o2\n\t"
315 "ldd [%%o2],%%l0\n\t"
316 "ldd [%%o2+8],%%l2\n\t"
317 "ldd [%%o2+0x10],%%l4\n\t"
318 "ldd [%%o2+0x18],%%l6\n\t"
319 "ldd [%%o2+0x20],%%i0\n\t"
320 "ldd [%%o2+0x28],%%i2\n\t"
321 "ldd [%%o2+0x30],%%i4\n\t"
322 "ldd [%%o2+0x38],%%i6\n\t"
323 "mov %%o2,%%sp\n\t"
324 "ld [%%o1],%%o2\n\t"
325 "ld [%%o1+8],%%o0\n\t"
326 "jmpl %%o2,%%g0\n\t"
327 "nop\n\t"
328 "1:\n"
329 : : "r"(from),"r"(to),"r"(__tmp_stack)
330 : "g1","o0","o1","o2","o3","o4","o5","o7","memory","cc");
331}
332
333#define COCO_MAKECTX(coco, buf, func, stack, a0) \
334 buf[0] = (void *)(func); \
335 buf[1] = (void *)(stack); \
336 buf[2] = (void *)(a0); \
337 stack[0] = 0; \
338 stack[1] = 0; \
339 stack[2] = 0; \
340 stack[3] = 0; \
341 stack[4] = 0; \
342 stack[5] = 0; \
343 stack[6] = 0; \
344 stack[7] = 0; \
345 stack[8] = 0; \
346 stack[9] = 0; \
347 stack[10] = 0; \
348 stack[11] = 0; \
349 stack[12] = 0; \
350 stack[13] = 0; \
351 stack[14] = (size_t)&stack[COCO_STACKADJUST]; \
352 stack[15] = 0xdeadc0c0; /* Dummy return address. */ \
353
354#endif /* !define(__LP64__) */
355
356#endif /* arch check */
357
358#endif /* !(__GNUC__ >= 3 && !defined(COCO_USE_SETJMP)) */
359
360/* Try _setjmp/_longjmp with a patched jump buffer. */
361#ifndef COCO_MAKECTX
362#include <setjmp.h>
363
364/* Check for supported CPU+OS combinations. */
365#if defined(__i386) || defined(__i386__)
366
367#define COCO_STATE_HEAD size_t arg0;
368#define COCO_SETJMP_X86(coco, stack, a0) \
369 stack[COCO_STACKADJUST-1] = 0xdeadc0c0; /* Dummy return address. */ \
370 coco->arg0 = (size_t)(a0);
371
372#if __GLIBC__ == 2 && defined(JB_SP) /* x86-linux-glibc2 */
373#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
374 buf->__jmpbuf[JB_PC] = (int)(func); \
375 buf->__jmpbuf[JB_SP] = (int)(stack); \
376 buf->__jmpbuf[JB_BP] = 0; \
377 COCO_SETJMP_X86(coco, stack, a0)
378#elif defined(__linux__) && defined(_I386_JMP_BUF_H) /* x86-linux-libc5 */
379#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
380 buf->__pc = (func); \
381 buf->__sp = (stack); \
382 buf->__bp = NULL; \
383 COCO_SETJMP_X86(coco, stack, a0)
384#elif defined(__FreeBSD__) /* x86-FreeBSD */
385#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
386 buf->_jb[0] = (long)(func); \
387 buf->_jb[2] = (long)(stack); \
388 buf->_jb[3] = 0; /* ebp */ \
389 COCO_SETJMP_X86(coco, stack, a0)
390#define COCO_STACKADJUST 2
391#elif defined(__NetBSD__) || defined(__OpenBSD__) /* x86-NetBSD, x86-OpenBSD */
392#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
393 buf[0] = (long)(func); \
394 buf[2] = (long)(stack); \
395 buf[3] = 0; /* ebp */ \
396 COCO_SETJMP_X86(coco, stack, a0)
397#define COCO_STACKADJUST 2
398#elif defined(__solaris__) && _JBLEN == 10 /* x86-solaris */
399#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
400 buf[5] = (int)(func); \
401 buf[4] = (int)(stack); \
402 buf[3] = 0; \
403 COCO_SETJMP_X86(coco, stack, a0)
404#elif defined(__MACH__) && defined(_BSD_I386_SETJMP_H) /* x86-macosx */
405#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
406 buf[12] = (int)(func); \
407 buf[9] = (int)(stack); \
408 buf[8] = 0; /* ebp */ \
409 COCO_SETJMP_X86(coco, stack, a0)
410#endif
411
412#elif defined(__x86_64__) || defined(__x86_64)
413
414#define COCO_STATE_HEAD size_t arg0;
415
416#define COCO_MAIN_PARAM \
417 int _a, int _b, int _c, int _d, int _e, int _f, lua_State *L
418
419#if defined(__solaris__) && _JBLEN == 8 /* x64-solaris */
420#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
421 buf[7] = (long)(func); \
422 buf[6] = (long)(stack); \
423 buf[5] = 0; \
424 stack[0] = 0xdeadc0c0; /* Dummy return address. */ \
425 coco->arg0 = (size_t)(a0);
426#endif
427
428#elif defined(PPC) || defined(__ppc__) || defined(__PPC__) || \
429 defined(__powerpc__) || defined(__POWERPC__) || defined(_ARCH_PPC)
430
431#define COCO_STACKADJUST 16
432#define COCO_MAIN_PARAM \
433 int _a, int _b, int _c, int _d, int _e, int _f, int _g, int _h, lua_State *L
434
435#if defined(__MACH__) && defined(_BSD_PPC_SETJMP_H_) /* ppc32-macosx */
436#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
437 buf[21] = (int)(func); \
438 buf[0] = (int)(stack); \
439 stack[6+8] = (size_t)(a0);
440#endif
441
442#elif (defined(MIPS) || defined(MIPSEL) || defined(__mips)) && \
443 _MIPS_SIM == _MIPS_SIM_ABI32 && !defined(__mips_eabi)
444
445/* Stack layout for o32 ABI. */
446#define COCO_STACKADJUST 8
447#define COCO_MAIN_PARAM int _a, int _b, int _c, int _d, lua_State *L
448
449#if __GLIBC__ == 2 || defined(__UCLIBC__) /* mips32-linux-glibc2 */
450#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
451 buf->__jmpbuf->__pc = (func); /* = t9 in _longjmp. Reqd. for -mabicalls. */ \
452 buf->__jmpbuf->__sp = (stack); \
453 buf->__jmpbuf->__fp = (void *)0; \
454 stack[4] = (size_t)(a0);
455#endif
456
457#elif defined(__arm__) || defined(__ARM__)
458
459#if __GLIBC__ == 2 || defined(__UCLIBC__) /* arm-linux-glibc2 */
460#ifndef __JMP_BUF_SP
461#define __JMP_BUF_SP ((sizeof(__jmp_buf)/sizeof(int))-2)
462#endif
463#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
464 buf->__jmpbuf[__JMP_BUF_SP+1] = (int)(func); /* pc */ \
465 buf->__jmpbuf[__JMP_BUF_SP] = (int)(stack); /* sp */ \
466 buf->__jmpbuf[__JMP_BUF_SP-1] = 0; /* fp */ \
467 stack[0] = (size_t)(a0);
468#define COCO_STACKADJUST 2
469#define COCO_MAIN_PARAM int _a, int _b, int _c, int _d, lua_State *L
470#endif
471
472#endif /* arch check */
473
474#ifdef COCO_PATCHCTX
475#define COCO_CTX jmp_buf
476#define COCO_MAKECTX(coco, buf, func, stack, a0) \
477 _setjmp(buf); COCO_PATCHCTX(coco, buf, func, stack, a0)
478#define COCO_SWITCH(from, to) if (!_setjmp(from)) _longjmp(to, 1);
479#endif
480
481#endif /* !defined(COCO_MAKECTX) */
482
483#endif /* !defined(COCO_USE_UCONTEXT) */
484
485/* ------------------------------------------------------------------------ */
486
487/* Use inline asm or _setjmp/_longjmp if available. */
488#ifdef COCO_MAKECTX
489
490#ifndef COCO_STACKADJUST
491#define COCO_STACKADJUST 1
492#endif
493
494#define COCO_FILL(coco, NL, mainfunc) \
495{ /* Include the return address to get proper stack alignment. */ \
496 size_t *stackptr = &((size_t *)coco)[-COCO_STACKADJUST]; \
497 COCO_MAKECTX(coco, coco->ctx, mainfunc, stackptr, NL) \
498}
499
500/* ------------------------------------------------------------------------ */
501
502/* Else fallback to ucontext. Slower, because it saves/restores signals. */
503#else /* !defined(COCO_MAKECTX) */
504
505#include <ucontext.h>
506
507#define COCO_CTX ucontext_t
508
509/* Ugly workaround for makecontext() deficiencies on 64 bit CPUs. */
510/* Note that WIN64 (which is LLP64) never comes here. See above. */
511#if defined(__LP64__) || defined(_LP64) || INT_MAX != LONG_MAX
512/* 64 bit CPU: split the pointer into two 32 bit ints. */
513#define COCO_MAIN_PARAM unsigned int lo, unsigned int hi
514#define COCO_MAIN_GETL \
515 lua_State *L = (lua_State *)((((unsigned long)hi)<<32)+(unsigned long)lo);
516#define COCO_MAKECTX(coco, NL, mainfunc) \
517 makecontext(&coco->ctx, mainfunc, 2, \
518 (int)(ptrdiff_t)NL, (int)((ptrdiff_t)NL>>32));
519#else
520/* 32 bit CPU: a pointer fits into an int. */
521#define COCO_MAKECTX(coco, NL, mainfunc) \
522 makecontext(&coco->ctx, mainfunc, 1, (int)NL);
523#endif
524
525#define COCO_FILL(coco, NL, mainfunc) \
526 getcontext(&coco->ctx); \
527 coco->ctx.uc_link = NULL; /* We never exit from coco_main. */ \
528 coco->ctx.uc_stack.ss_sp = coco->allocptr; \
529 coco->ctx.uc_stack.ss_size = (char *)coco - (char *)(coco->allocptr); \
530 COCO_MAKECTX(coco, NL, mainfunc)
531
532#define COCO_SWITCH(from, to) swapcontext(&(from), &(to));
533
534#endif /* !defined(COCO_MAKECTX) */
535
536
537/* Common code for inline asm/setjmp/ucontext to allocate/free the stack. */
538
539struct coco_State {
540#ifdef COCO_STATE_HEAD
541 COCO_STATE_HEAD
542#endif
543 COCO_CTX ctx; /* Own context. */
544 COCO_CTX back; /* Context to switch back to. */
545 void *allocptr; /* Pointer to allocated memory. */
546 int allocsize; /* Size of allocated memory. */
547 int nargs; /* Number of arguments to pass. */
548 STACK_VGID /* Optional valgrind stack id. See above. */
549};
550
551typedef void (*coco_MainFunc)(void);
552
553/* Put the Coco state at the end and align it downwards. */
554#define ALIGNED_END(p, s, t) \
555 ((t *)(((char *)0) + ((((char *)(p)-(char *)0)+(s)-sizeof(t)) & -16)))
556
557/* TODO: use mmap. */
558#define COCO_NEW(OL, NL, cstacksize, mainfunc) \
559{ \
560 void *ptr = luaM_malloc(OL, cstacksize); \
561 coco_State *coco = ALIGNED_END(ptr, cstacksize, coco_State); \
562 STACK_REG(coco, ptr, cstacksize) \
563 coco->allocptr = ptr; \
564 coco->allocsize = cstacksize; \
565 COCO_FILL(coco, NL, mainfunc) \
566 L2COCO(NL) = coco; \
567}
568
569#define COCO_FREE(L) \
570 STACK_DEREG(L2COCO(L)) \
571 luaM_freemem(L, L2COCO(L)->allocptr, L2COCO(L)->allocsize); \
572 L2COCO(L) = NULL;
573
574#define COCO_JUMPIN(coco) COCO_SWITCH(coco->back, coco->ctx)
575#define COCO_JUMPOUT(coco) COCO_SWITCH(coco->ctx, coco->back)
576
577#endif /* !COCO_USE_FIBERS */
578
579/* ------------------------------------------------------------------------ */
580
581#ifndef COCO_MIN_CSTACKSIZE
582#define COCO_MIN_CSTACKSIZE (32768+4096)
583#endif
584
585/* Don't use multiples of 64K to avoid D-cache aliasing conflicts. */
586#ifndef COCO_DEFAULT_CSTACKSIZE
587#define COCO_DEFAULT_CSTACKSIZE (65536-4096)
588#endif
589
590static int defaultcstacksize = COCO_DEFAULT_CSTACKSIZE;
591
592/* Start the Lua or C function. */
593static void coco_start(lua_State *L, void *ud)
594{
595 if (luaD_precall(L, (StkId)ud, LUA_MULTRET) == PCRLUA)
596 luaV_execute(L, L->ci - L->base_ci);
597}
598
599#ifndef COCO_MAIN_PARAM
600#define COCO_MAIN_PARAM lua_State *L
601#endif
602
603#ifndef COCO_MAIN_DECL
604#define COCO_MAIN_DECL
605#endif
606
607/* Toplevel function for the new coroutine stack. Never exits. */
608static void COCO_MAIN_DECL coco_main(COCO_MAIN_PARAM)
609{
610#ifdef COCO_MAIN_GETL
611 COCO_MAIN_GETL
612#endif
613 coco_State *coco = L2COCO(L);
614 for (;;) {
615 L->status = luaD_rawrunprotected(L, coco_start, L->top - (coco->nargs+1));
616 if (L->status != 0) luaD_seterrorobj(L, L->status, L->top);
617 COCO_JUMPOUT(coco)
618 }
619}
620
621/* Add a C stack to a coroutine. */
622lua_State *lua_newcthread(lua_State *OL, int cstacksize)
623{
624 lua_State *NL = lua_newthread(OL);
625
626 if (cstacksize < 0)
627 return NL;
628 if (cstacksize == 0)
629 cstacksize = defaultcstacksize;
630 else if (cstacksize < COCO_MIN_CSTACKSIZE)
631 cstacksize = COCO_MIN_CSTACKSIZE;
632 cstacksize &= -16;
633
634 COCO_NEW(OL, NL, cstacksize, ((coco_MainFunc)(coco_main)))
635
636 return NL;
637}
638
639/* Free the C stack of a coroutine. Called from lstate.c. */
640void luaCOCO_free(lua_State *L)
641{
642 COCO_FREE(L)
643}
644
645/* Resume a coroutine with a C stack. Called from ldo.c. */
646int luaCOCO_resume(lua_State *L, int nargs)
647{
648 coco_State *coco = L2COCO(L);
649 coco->nargs = nargs;
650 COCO_JUMPIN(coco)
651#ifndef COCO_DISABLE_EARLY_FREE
652 if (L->status != LUA_YIELD) {
653 COCO_FREE(L)
654 }
655#endif
656 return L->status;
657}
658
659/* Yield from a coroutine with a C stack. Called from ldo.c. */
660int luaCOCO_yield(lua_State *L)
661{
662 coco_State *coco = L2COCO(L);
663 L->status = LUA_YIELD;
664 COCO_JUMPOUT(coco)
665 L->status = 0;
666 {
667 StkId base = L->top - coco->nargs;
668 StkId rbase = L->base;
669 if (rbase < base) { /* Need to move args down? */
670 while (base < L->top)
671 setobjs2s(L, rbase++, base++);
672 L->top = rbase;
673 }
674 }
675 L->base = L->ci->base; /* Restore invariant. */
676 return coco->nargs;
677}
678
679/* Get/set the default C stack size. */
680int luaCOCO_cstacksize(int cstacksize)
681{
682 int oldsz = defaultcstacksize;
683 if (cstacksize >= 0) {
684 if (cstacksize == 0)
685 cstacksize = COCO_DEFAULT_CSTACKSIZE;
686 else if (cstacksize < COCO_MIN_CSTACKSIZE)
687 cstacksize = COCO_MIN_CSTACKSIZE;
688 defaultcstacksize = cstacksize;
689 }
690 return oldsz;
691}
692
693#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lcoco.h b/libraries/LuaJIT-1.1.7/src/lcoco.h
new file mode 100644
index 0000000..9fb6207
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lcoco.h
@@ -0,0 +1,72 @@
1/*
2** Lua/Coco glue.
3** Copyright (C) 2004-2011 Mike Pall. See copyright notice in lcoco.c
4*/
5
6#ifndef lcoco_h
7#define lcoco_h
8
9#define LUACOCO_VERSION "Coco 1.1.6"
10#define LUACOCO_VERSION_NUM 10106
11
12/* Exported C API to add a C stack to a coroutine. */
13LUA_API lua_State *lua_newcthread(lua_State *L, int cstacksize);
14
15/* Internal support routines. */
16LUAI_FUNC void luaCOCO_free(lua_State *L);
17LUAI_FUNC int luaCOCO_resume(lua_State *L, int nargs);
18LUAI_FUNC int luaCOCO_yield(lua_State *L);
19LUAI_FUNC int luaCOCO_cstacksize(int cstacksize);
20
21/* Forward declaration. */
22typedef struct coco_State coco_State;
23
24/* These are redefined below. */
25#undef LUAI_EXTRASPACE
26#undef luai_userstateopen
27/* luai_userstateclose unused */
28#undef luai_userstatethread
29#undef luai_userstatefree
30#undef luai_userstateresume
31#undef luai_userstateyield
32
33/* Use Windows Fibers (Win98+). */
34#if defined(_WIN32)
35
36/* Fibers allocate their own stack. The whole Coco state is in front of L. */
37struct coco_State {
38 void *fib; /* Own fiber (if any). */
39 void *back; /* Fiber to switch back to. */
40 int nargs; /* Number of arguments to pass. */
41 int dummy_align;
42};
43
44#define L2COCO(L) (&((coco_State *)(L))[-1])
45#define LHASCOCO(L) (L2COCO(L)->fib)
46#define LUAI_EXTRASPACE sizeof(coco_State)
47#define luai_userstateopen(L) L2COCO(L)->fib = NULL
48#define luai_userstatethread(L,L1) L2COCO(L1)->fib = NULL
49#define COCO_USE_FIBERS
50
51#else /* !defined(_WIN32) */
52
53/* The Coco state depends on the context switch method used. See lcoco.c. */
54/* It's stored at the end of the stack. Only need a pointer in front of L. */
55#define L2COCO(L) (((coco_State **)(L))[-1])
56#define LHASCOCO(L) (L2COCO(L))
57/* This wastes some space on 32 bit systems, but gets better alignment. */
58#define LUAI_EXTRASPACE sizeof(LUAI_USER_ALIGNMENT_T)
59#define luai_userstateopen(L) L2COCO(L) = NULL
60#define luai_userstatethread(L,L1) L2COCO(L1) = NULL
61
62#endif /* !defined(_WIN32) */
63
64#define luai_userstatefree(L) if (LHASCOCO(L)) luaCOCO_free(L)
65#define luai_userstateresume(L, nargs) \
66 if (LHASCOCO(L)) return luaCOCO_resume(L, nargs)
67#define luai_userstateyield(L, nresults) \
68 do { if (LHASCOCO(L)) { \
69 L->base = L->top - (nresults); /* Protect stack slots below. */ \
70 return luaCOCO_yield(L); } } while (0)
71
72#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lcode.c b/libraries/LuaJIT-1.1.7/src/lcode.c
new file mode 100644
index 0000000..c13066e
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lcode.c
@@ -0,0 +1,831 @@
1/*
2** $Id: lcode.c,v 2.25.1.3 2007/12/28 15:32:23 roberto Exp $
3** Code generator for Lua
4** See Copyright Notice in lua.h
5*/
6
7
8#include <stdlib.h>
9
10#define lcode_c
11#define LUA_CORE
12
13#include "lua.h"
14
15#include "lcode.h"
16#include "ldebug.h"
17#include "ldo.h"
18#include "lgc.h"
19#include "llex.h"
20#include "lmem.h"
21#include "lobject.h"
22#include "lopcodes.h"
23#include "lparser.h"
24#include "ltable.h"
25
26
27#define hasjumps(e) ((e)->t != (e)->f)
28
29
30static int isnumeral(expdesc *e) {
31 return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);
32}
33
34
35void luaK_nil (FuncState *fs, int from, int n) {
36 Instruction *previous;
37 if (fs->pc > fs->lasttarget) { /* no jumps to current position? */
38 if (fs->pc == 0) { /* function start? */
39 if (from >= fs->nactvar)
40 return; /* positions are already clean */
41 }
42 else {
43 previous = &fs->f->code[fs->pc-1];
44 if (GET_OPCODE(*previous) == OP_LOADNIL) {
45 int pfrom = GETARG_A(*previous);
46 int pto = GETARG_B(*previous);
47 if (pfrom <= from && from <= pto+1) { /* can connect both? */
48 if (from+n-1 > pto)
49 SETARG_B(*previous, from+n-1);
50 return;
51 }
52 }
53 }
54 }
55 luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0); /* else no optimization */
56}
57
58
59int luaK_jump (FuncState *fs) {
60 int jpc = fs->jpc; /* save list of jumps to here */
61 int j;
62 fs->jpc = NO_JUMP;
63 j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
64 luaK_concat(fs, &j, jpc); /* keep them on hold */
65 return j;
66}
67
68
69void luaK_ret (FuncState *fs, int first, int nret) {
70 luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);
71}
72
73
74static int condjump (FuncState *fs, OpCode op, int A, int B, int C) {
75 luaK_codeABC(fs, op, A, B, C);
76 return luaK_jump(fs);
77}
78
79
80static void fixjump (FuncState *fs, int pc, int dest) {
81 Instruction *jmp = &fs->f->code[pc];
82 int offset = dest-(pc+1);
83 lua_assert(dest != NO_JUMP);
84 if (abs(offset) > MAXARG_sBx)
85 luaX_syntaxerror(fs->ls, "control structure too long");
86 SETARG_sBx(*jmp, offset);
87}
88
89
90/*
91** returns current `pc' and marks it as a jump target (to avoid wrong
92** optimizations with consecutive instructions not in the same basic block).
93*/
94int luaK_getlabel (FuncState *fs) {
95 fs->lasttarget = fs->pc;
96 return fs->pc;
97}
98
99
100static int getjump (FuncState *fs, int pc) {
101 int offset = GETARG_sBx(fs->f->code[pc]);
102 if (offset == NO_JUMP) /* point to itself represents end of list */
103 return NO_JUMP; /* end of list */
104 else
105 return (pc+1)+offset; /* turn offset into absolute position */
106}
107
108
109static Instruction *getjumpcontrol (FuncState *fs, int pc) {
110 Instruction *pi = &fs->f->code[pc];
111 if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
112 return pi-1;
113 else
114 return pi;
115}
116
117
118/*
119** check whether list has any jump that do not produce a value
120** (or produce an inverted value)
121*/
122static int need_value (FuncState *fs, int list) {
123 for (; list != NO_JUMP; list = getjump(fs, list)) {
124 Instruction i = *getjumpcontrol(fs, list);
125 if (GET_OPCODE(i) != OP_TESTSET) return 1;
126 }
127 return 0; /* not found */
128}
129
130
131static int patchtestreg (FuncState *fs, int node, int reg) {
132 Instruction *i = getjumpcontrol(fs, node);
133 if (GET_OPCODE(*i) != OP_TESTSET)
134 return 0; /* cannot patch other instructions */
135 if (reg != NO_REG && reg != GETARG_B(*i))
136 SETARG_A(*i, reg);
137 else /* no register to put value or register already has the value */
138 *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
139
140 return 1;
141}
142
143
144static void removevalues (FuncState *fs, int list) {
145 for (; list != NO_JUMP; list = getjump(fs, list))
146 patchtestreg(fs, list, NO_REG);
147}
148
149
150static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
151 int dtarget) {
152 while (list != NO_JUMP) {
153 int next = getjump(fs, list);
154 if (patchtestreg(fs, list, reg))
155 fixjump(fs, list, vtarget);
156 else
157 fixjump(fs, list, dtarget); /* jump to default target */
158 list = next;
159 }
160}
161
162
163static void dischargejpc (FuncState *fs) {
164 patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);
165 fs->jpc = NO_JUMP;
166}
167
168
169void luaK_patchlist (FuncState *fs, int list, int target) {
170 if (target == fs->pc)
171 luaK_patchtohere(fs, list);
172 else {
173 lua_assert(target < fs->pc);
174 patchlistaux(fs, list, target, NO_REG, target);
175 }
176}
177
178
179void luaK_patchtohere (FuncState *fs, int list) {
180 luaK_getlabel(fs);
181 luaK_concat(fs, &fs->jpc, list);
182}
183
184
185void luaK_concat (FuncState *fs, int *l1, int l2) {
186 if (l2 == NO_JUMP) return;
187 else if (*l1 == NO_JUMP)
188 *l1 = l2;
189 else {
190 int list = *l1;
191 int next;
192 while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */
193 list = next;
194 fixjump(fs, list, l2);
195 }
196}
197
198
199void luaK_checkstack (FuncState *fs, int n) {
200 int newstack = fs->freereg + n;
201 if (newstack > fs->f->maxstacksize) {
202 if (newstack >= MAXSTACK)
203 luaX_syntaxerror(fs->ls, "function or expression too complex");
204 fs->f->maxstacksize = cast_byte(newstack);
205 }
206}
207
208
209void luaK_reserveregs (FuncState *fs, int n) {
210 luaK_checkstack(fs, n);
211 fs->freereg += n;
212}
213
214
215static void freereg (FuncState *fs, int reg) {
216 if (!ISK(reg) && reg >= fs->nactvar) {
217 fs->freereg--;
218 lua_assert(reg == fs->freereg);
219 }
220}
221
222
223static void freeexp (FuncState *fs, expdesc *e) {
224 if (e->k == VNONRELOC)
225 freereg(fs, e->u.s.info);
226}
227
228
229static int addk (FuncState *fs, TValue *k, TValue *v) {
230 lua_State *L = fs->L;
231 TValue *idx = luaH_set(L, fs->h, k);
232 Proto *f = fs->f;
233 int oldsize = f->sizek;
234 if (ttisnumber(idx)) {
235 lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));
236 return cast_int(nvalue(idx));
237 }
238 else { /* constant not found; create a new entry */
239 setnvalue(idx, cast_num(fs->nk));
240 luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
241 MAXARG_Bx, "constant table overflow");
242 while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
243 setobj(L, &f->k[fs->nk], v);
244 luaC_barrier(L, f, v);
245 return fs->nk++;
246 }
247}
248
249
250int luaK_stringK (FuncState *fs, TString *s) {
251 TValue o;
252 setsvalue(fs->L, &o, s);
253 return addk(fs, &o, &o);
254}
255
256
257int luaK_numberK (FuncState *fs, lua_Number r) {
258 TValue o;
259 setnvalue(&o, r);
260 return addk(fs, &o, &o);
261}
262
263
264static int boolK (FuncState *fs, int b) {
265 TValue o;
266 setbvalue(&o, b);
267 return addk(fs, &o, &o);
268}
269
270
271static int nilK (FuncState *fs) {
272 TValue k, v;
273 setnilvalue(&v);
274 /* cannot use nil as key; instead use table itself to represent nil */
275 sethvalue(fs->L, &k, fs->h);
276 return addk(fs, &k, &v);
277}
278
279
280void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
281 if (e->k == VCALL) { /* expression is an open function call? */
282 SETARG_C(getcode(fs, e), nresults+1);
283 }
284 else if (e->k == VVARARG) {
285 SETARG_B(getcode(fs, e), nresults+1);
286 SETARG_A(getcode(fs, e), fs->freereg);
287 luaK_reserveregs(fs, 1);
288 }
289}
290
291
292void luaK_setoneret (FuncState *fs, expdesc *e) {
293 if (e->k == VCALL) { /* expression is an open function call? */
294 e->k = VNONRELOC;
295 e->u.s.info = GETARG_A(getcode(fs, e));
296 }
297 else if (e->k == VVARARG) {
298 SETARG_B(getcode(fs, e), 2);
299 e->k = VRELOCABLE; /* can relocate its simple result */
300 }
301}
302
303
304void luaK_dischargevars (FuncState *fs, expdesc *e) {
305 switch (e->k) {
306 case VLOCAL: {
307 e->k = VNONRELOC;
308 break;
309 }
310 case VUPVAL: {
311 e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);
312 e->k = VRELOCABLE;
313 break;
314 }
315 case VGLOBAL: {
316 e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);
317 e->k = VRELOCABLE;
318 break;
319 }
320 case VINDEXED: {
321 freereg(fs, e->u.s.aux);
322 freereg(fs, e->u.s.info);
323 e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);
324 e->k = VRELOCABLE;
325 break;
326 }
327 case VVARARG:
328 case VCALL: {
329 luaK_setoneret(fs, e);
330 break;
331 }
332 default: break; /* there is one value available (somewhere) */
333 }
334}
335
336
337static int code_label (FuncState *fs, int A, int b, int jump) {
338 luaK_getlabel(fs); /* those instructions may be jump targets */
339 return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);
340}
341
342
343static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
344 luaK_dischargevars(fs, e);
345 switch (e->k) {
346 case VNIL: {
347 luaK_nil(fs, reg, 1);
348 break;
349 }
350 case VFALSE: case VTRUE: {
351 luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
352 break;
353 }
354 case VK: {
355 luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
356 break;
357 }
358 case VKNUM: {
359 luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
360 break;
361 }
362 case VRELOCABLE: {
363 Instruction *pc = &getcode(fs, e);
364 SETARG_A(*pc, reg);
365 break;
366 }
367 case VNONRELOC: {
368 if (reg != e->u.s.info)
369 luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
370 break;
371 }
372 default: {
373 lua_assert(e->k == VVOID || e->k == VJMP);
374 return; /* nothing to do... */
375 }
376 }
377 e->u.s.info = reg;
378 e->k = VNONRELOC;
379}
380
381
382static void discharge2anyreg (FuncState *fs, expdesc *e) {
383 if (e->k != VNONRELOC) {
384 luaK_reserveregs(fs, 1);
385 discharge2reg(fs, e, fs->freereg-1);
386 }
387}
388
389
390static void exp2reg (FuncState *fs, expdesc *e, int reg) {
391 discharge2reg(fs, e, reg);
392 if (e->k == VJMP)
393 luaK_concat(fs, &e->t, e->u.s.info); /* put this jump in `t' list */
394 if (hasjumps(e)) {
395 int final; /* position after whole expression */
396 int p_f = NO_JUMP; /* position of an eventual LOAD false */
397 int p_t = NO_JUMP; /* position of an eventual LOAD true */
398 if (need_value(fs, e->t) || need_value(fs, e->f)) {
399 int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
400 p_f = code_label(fs, reg, 0, 1);
401 p_t = code_label(fs, reg, 1, 0);
402 luaK_patchtohere(fs, fj);
403 }
404 final = luaK_getlabel(fs);
405 patchlistaux(fs, e->f, final, reg, p_f);
406 patchlistaux(fs, e->t, final, reg, p_t);
407 }
408 e->f = e->t = NO_JUMP;
409 e->u.s.info = reg;
410 e->k = VNONRELOC;
411}
412
413
414void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
415 luaK_dischargevars(fs, e);
416 freeexp(fs, e);
417 luaK_reserveregs(fs, 1);
418 exp2reg(fs, e, fs->freereg - 1);
419}
420
421
422int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
423 luaK_dischargevars(fs, e);
424 if (e->k == VNONRELOC) {
425 if (!hasjumps(e)) return e->u.s.info; /* exp is already in a register */
426 if (e->u.s.info >= fs->nactvar) { /* reg. is not a local? */
427 exp2reg(fs, e, e->u.s.info); /* put value on it */
428 return e->u.s.info;
429 }
430 }
431 luaK_exp2nextreg(fs, e); /* default */
432 return e->u.s.info;
433}
434
435
436void luaK_exp2val (FuncState *fs, expdesc *e) {
437 if (hasjumps(e))
438 luaK_exp2anyreg(fs, e);
439 else
440 luaK_dischargevars(fs, e);
441}
442
443
444int luaK_exp2RK (FuncState *fs, expdesc *e) {
445 luaK_exp2val(fs, e);
446 switch (e->k) {
447 case VKNUM:
448 case VTRUE:
449 case VFALSE:
450 case VNIL: {
451 if (fs->nk <= MAXINDEXRK) { /* constant fit in RK operand? */
452 e->u.s.info = (e->k == VNIL) ? nilK(fs) :
453 (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
454 boolK(fs, (e->k == VTRUE));
455 e->k = VK;
456 return RKASK(e->u.s.info);
457 }
458 else break;
459 }
460 case VK: {
461 if (e->u.s.info <= MAXINDEXRK) /* constant fit in argC? */
462 return RKASK(e->u.s.info);
463 else break;
464 }
465 default: break;
466 }
467 /* not a constant in the right range: put it in a register */
468 return luaK_exp2anyreg(fs, e);
469}
470
471
472void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
473 switch (var->k) {
474 case VLOCAL: {
475 freeexp(fs, ex);
476 exp2reg(fs, ex, var->u.s.info);
477 return;
478 }
479 case VUPVAL: {
480 int e = luaK_exp2anyreg(fs, ex);
481 luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
482 break;
483 }
484 case VGLOBAL: {
485 int e = luaK_exp2anyreg(fs, ex);
486 luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
487 break;
488 }
489 case VINDEXED: {
490 int e = luaK_exp2RK(fs, ex);
491 luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
492 break;
493 }
494 default: {
495 lua_assert(0); /* invalid var kind to store */
496 break;
497 }
498 }
499 freeexp(fs, ex);
500}
501
502
503void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
504 int func;
505 luaK_exp2anyreg(fs, e);
506 freeexp(fs, e);
507 func = fs->freereg;
508 luaK_reserveregs(fs, 2);
509 luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
510 freeexp(fs, key);
511 e->u.s.info = func;
512 e->k = VNONRELOC;
513}
514
515
516static void invertjump (FuncState *fs, expdesc *e) {
517 Instruction *pc = getjumpcontrol(fs, e->u.s.info);
518 lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
519 GET_OPCODE(*pc) != OP_TEST);
520 SETARG_A(*pc, !(GETARG_A(*pc)));
521}
522
523
524static int jumponcond (FuncState *fs, expdesc *e, int cond) {
525 if (e->k == VRELOCABLE) {
526 Instruction ie = getcode(fs, e);
527 if (GET_OPCODE(ie) == OP_NOT) {
528 fs->pc--; /* remove previous OP_NOT */
529 return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
530 }
531 /* else go through */
532 }
533 discharge2anyreg(fs, e);
534 freeexp(fs, e);
535 return condjump(fs, OP_TESTSET, NO_REG, e->u.s.info, cond);
536}
537
538
539void luaK_goiftrue (FuncState *fs, expdesc *e) {
540 int pc; /* pc of last jump */
541 luaK_dischargevars(fs, e);
542 switch (e->k) {
543 case VK: case VKNUM: case VTRUE: {
544 pc = NO_JUMP; /* always true; do nothing */
545 break;
546 }
547 case VJMP: {
548 invertjump(fs, e);
549 pc = e->u.s.info;
550 break;
551 }
552 default: {
553 pc = jumponcond(fs, e, 0);
554 break;
555 }
556 }
557 luaK_concat(fs, &e->f, pc); /* insert last jump in `f' list */
558 luaK_patchtohere(fs, e->t);
559 e->t = NO_JUMP;
560}
561
562
563static void luaK_goiffalse (FuncState *fs, expdesc *e) {
564 int pc; /* pc of last jump */
565 luaK_dischargevars(fs, e);
566 switch (e->k) {
567 case VNIL: case VFALSE: {
568 pc = NO_JUMP; /* always false; do nothing */
569 break;
570 }
571 case VJMP: {
572 pc = e->u.s.info;
573 break;
574 }
575 default: {
576 pc = jumponcond(fs, e, 1);
577 break;
578 }
579 }
580 luaK_concat(fs, &e->t, pc); /* insert last jump in `t' list */
581 luaK_patchtohere(fs, e->f);
582 e->f = NO_JUMP;
583}
584
585
586static void codenot (FuncState *fs, expdesc *e) {
587 luaK_dischargevars(fs, e);
588 switch (e->k) {
589 case VNIL: case VFALSE: {
590 e->k = VTRUE;
591 break;
592 }
593 case VK: case VKNUM: case VTRUE: {
594 e->k = VFALSE;
595 break;
596 }
597 case VJMP: {
598 invertjump(fs, e);
599 break;
600 }
601 case VRELOCABLE:
602 case VNONRELOC: {
603 discharge2anyreg(fs, e);
604 freeexp(fs, e);
605 e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0);
606 e->k = VRELOCABLE;
607 break;
608 }
609 default: {
610 lua_assert(0); /* cannot happen */
611 break;
612 }
613 }
614 /* interchange true and false lists */
615 { int temp = e->f; e->f = e->t; e->t = temp; }
616 removevalues(fs, e->f);
617 removevalues(fs, e->t);
618}
619
620
621void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
622 t->u.s.aux = luaK_exp2RK(fs, k);
623 t->k = VINDEXED;
624}
625
626
627static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {
628 lua_Number v1, v2, r;
629 if (!isnumeral(e1) || !isnumeral(e2)) return 0;
630 v1 = e1->u.nval;
631 v2 = e2->u.nval;
632 switch (op) {
633 case OP_ADD: r = luai_numadd(v1, v2); break;
634 case OP_SUB: r = luai_numsub(v1, v2); break;
635 case OP_MUL: r = luai_nummul(v1, v2); break;
636 case OP_DIV:
637 if (v2 == 0) return 0; /* do not attempt to divide by 0 */
638 r = luai_numdiv(v1, v2); break;
639 case OP_MOD:
640 if (v2 == 0) return 0; /* do not attempt to divide by 0 */
641 r = luai_nummod(v1, v2); break;
642 case OP_POW: r = luai_numpow(v1, v2); break;
643 case OP_UNM: r = luai_numunm(v1); break;
644 case OP_LEN: return 0; /* no constant folding for 'len' */
645 default: lua_assert(0); r = 0; break;
646 }
647 if (luai_numisnan(r)) return 0; /* do not attempt to produce NaN */
648 e1->u.nval = r;
649 return 1;
650}
651
652
653static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
654 if (constfolding(op, e1, e2))
655 return;
656 else {
657 int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
658 int o1 = luaK_exp2RK(fs, e1);
659 if (o1 > o2) {
660 freeexp(fs, e1);
661 freeexp(fs, e2);
662 }
663 else {
664 freeexp(fs, e2);
665 freeexp(fs, e1);
666 }
667 e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
668 e1->k = VRELOCABLE;
669 }
670}
671
672
673static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1,
674 expdesc *e2) {
675 int o1 = luaK_exp2RK(fs, e1);
676 int o2 = luaK_exp2RK(fs, e2);
677 freeexp(fs, e2);
678 freeexp(fs, e1);
679 if (cond == 0 && op != OP_EQ) {
680 int temp; /* exchange args to replace by `<' or `<=' */
681 temp = o1; o1 = o2; o2 = temp; /* o1 <==> o2 */
682 cond = 1;
683 }
684 e1->u.s.info = condjump(fs, op, cond, o1, o2);
685 e1->k = VJMP;
686}
687
688
689void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
690 expdesc e2;
691 e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
692 switch (op) {
693 case OPR_MINUS: {
694 if (!isnumeral(e))
695 luaK_exp2anyreg(fs, e); /* cannot operate on non-numeric constants */
696 codearith(fs, OP_UNM, e, &e2);
697 break;
698 }
699 case OPR_NOT: codenot(fs, e); break;
700 case OPR_LEN: {
701 luaK_exp2anyreg(fs, e); /* cannot operate on constants */
702 codearith(fs, OP_LEN, e, &e2);
703 break;
704 }
705 default: lua_assert(0);
706 }
707}
708
709
710void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
711 switch (op) {
712 case OPR_AND: {
713 luaK_goiftrue(fs, v);
714 break;
715 }
716 case OPR_OR: {
717 luaK_goiffalse(fs, v);
718 break;
719 }
720 case OPR_CONCAT: {
721 luaK_exp2nextreg(fs, v); /* operand must be on the `stack' */
722 break;
723 }
724 case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
725 case OPR_MOD: case OPR_POW: {
726 if (!isnumeral(v)) luaK_exp2RK(fs, v);
727 break;
728 }
729 default: {
730 luaK_exp2RK(fs, v);
731 break;
732 }
733 }
734}
735
736
737void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
738 switch (op) {
739 case OPR_AND: {
740 lua_assert(e1->t == NO_JUMP); /* list must be closed */
741 luaK_dischargevars(fs, e2);
742 luaK_concat(fs, &e2->f, e1->f);
743 *e1 = *e2;
744 break;
745 }
746 case OPR_OR: {
747 lua_assert(e1->f == NO_JUMP); /* list must be closed */
748 luaK_dischargevars(fs, e2);
749 luaK_concat(fs, &e2->t, e1->t);
750 *e1 = *e2;
751 break;
752 }
753 case OPR_CONCAT: {
754 luaK_exp2val(fs, e2);
755 if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {
756 lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1);
757 freeexp(fs, e1);
758 SETARG_B(getcode(fs, e2), e1->u.s.info);
759 e1->k = VRELOCABLE; e1->u.s.info = e2->u.s.info;
760 }
761 else {
762 luaK_exp2nextreg(fs, e2); /* operand must be on the 'stack' */
763 codearith(fs, OP_CONCAT, e1, e2);
764 }
765 break;
766 }
767 case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
768 case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
769 case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
770 case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
771 case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
772 case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
773 case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
774 case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
775 case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
776 case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
777 case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
778 case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
779 default: lua_assert(0);
780 }
781}
782
783
784void luaK_fixline (FuncState *fs, int line) {
785 fs->f->lineinfo[fs->pc - 1] = line;
786}
787
788
789static int luaK_code (FuncState *fs, Instruction i, int line) {
790 Proto *f = fs->f;
791 dischargejpc(fs); /* `pc' will change */
792 /* put new instruction in code array */
793 luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
794 MAX_INT, "code size overflow");
795 f->code[fs->pc] = i;
796 /* save corresponding line information */
797 luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
798 MAX_INT, "code size overflow");
799 f->lineinfo[fs->pc] = line;
800 return fs->pc++;
801}
802
803
804int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) {
805 lua_assert(getOpMode(o) == iABC);
806 lua_assert(getBMode(o) != OpArgN || b == 0);
807 lua_assert(getCMode(o) != OpArgN || c == 0);
808 return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline);
809}
810
811
812int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) {
813 lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx);
814 lua_assert(getCMode(o) == OpArgN);
815 return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);
816}
817
818
819void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
820 int c = (nelems - 1)/LFIELDS_PER_FLUSH + 1;
821 int b = (tostore == LUA_MULTRET) ? 0 : tostore;
822 lua_assert(tostore != 0);
823 if (c <= MAXARG_C)
824 luaK_codeABC(fs, OP_SETLIST, base, b, c);
825 else {
826 luaK_codeABC(fs, OP_SETLIST, base, b, 0);
827 luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
828 }
829 fs->freereg = base + 1; /* free registers with list values */
830}
831
diff --git a/libraries/LuaJIT-1.1.7/src/lcode.h b/libraries/LuaJIT-1.1.7/src/lcode.h
new file mode 100644
index 0000000..b941c60
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lcode.h
@@ -0,0 +1,76 @@
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*/
26typedef 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
36typedef 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
45LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
46LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
47LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
48LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
49LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
50LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
51LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
52LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
53LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
54LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
55LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
56LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
57LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
58LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
59LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
60LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
61LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
62LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
63LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
64LUAI_FUNC int luaK_jump (FuncState *fs);
65LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
66LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
67LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
68LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
69LUAI_FUNC int luaK_getlabel (FuncState *fs);
70LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
71LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
72LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
73LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
74
75
76#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ldblib.c b/libraries/LuaJIT-1.1.7/src/ldblib.c
new file mode 100644
index 0000000..21116ac
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldblib.c
@@ -0,0 +1,398 @@
1/*
2** $Id: ldblib.c,v 1.104.1.3 2008/01/21 13:11:21 roberto Exp $
3** Interface from Lua to its debug API
4** See Copyright Notice in lua.h
5*/
6
7
8#include <stdio.h>
9#include <stdlib.h>
10#include <string.h>
11
12#define ldblib_c
13#define LUA_LIB
14
15#include "lua.h"
16
17#include "lauxlib.h"
18#include "lualib.h"
19
20
21
22static int db_getregistry (lua_State *L) {
23 lua_pushvalue(L, LUA_REGISTRYINDEX);
24 return 1;
25}
26
27
28static int db_getmetatable (lua_State *L) {
29 luaL_checkany(L, 1);
30 if (!lua_getmetatable(L, 1)) {
31 lua_pushnil(L); /* no metatable */
32 }
33 return 1;
34}
35
36
37static int db_setmetatable (lua_State *L) {
38 int t = lua_type(L, 2);
39 luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
40 "nil or table expected");
41 lua_settop(L, 2);
42 lua_pushboolean(L, lua_setmetatable(L, 1));
43 return 1;
44}
45
46
47static int db_getfenv (lua_State *L) {
48 luaL_checkany(L, 1);
49 lua_getfenv(L, 1);
50 return 1;
51}
52
53
54static int db_setfenv (lua_State *L) {
55 luaL_checktype(L, 2, LUA_TTABLE);
56 lua_settop(L, 2);
57 if (lua_setfenv(L, 1) == 0)
58 luaL_error(L, LUA_QL("setfenv")
59 " cannot change environment of given object");
60 return 1;
61}
62
63
64static void settabss (lua_State *L, const char *i, const char *v) {
65 lua_pushstring(L, v);
66 lua_setfield(L, -2, i);
67}
68
69
70static void settabsi (lua_State *L, const char *i, int v) {
71 lua_pushinteger(L, v);
72 lua_setfield(L, -2, i);
73}
74
75
76static lua_State *getthread (lua_State *L, int *arg) {
77 if (lua_isthread(L, 1)) {
78 *arg = 1;
79 return lua_tothread(L, 1);
80 }
81 else {
82 *arg = 0;
83 return L;
84 }
85}
86
87
88static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
89 if (L == L1) {
90 lua_pushvalue(L, -2);
91 lua_remove(L, -3);
92 }
93 else
94 lua_xmove(L1, L, 1);
95 lua_setfield(L, -2, fname);
96}
97
98
99static int db_getinfo (lua_State *L) {
100 lua_Debug ar;
101 int arg;
102 lua_State *L1 = getthread(L, &arg);
103 const char *options = luaL_optstring(L, arg+2, "flnSu");
104 if (lua_isnumber(L, arg+1)) {
105 if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {
106 lua_pushnil(L); /* level out of range */
107 return 1;
108 }
109 }
110 else if (lua_isfunction(L, arg+1)) {
111 lua_pushfstring(L, ">%s", options);
112 options = lua_tostring(L, -1);
113 lua_pushvalue(L, arg+1);
114 lua_xmove(L, L1, 1);
115 }
116 else
117 return luaL_argerror(L, arg+1, "function or level expected");
118 if (!lua_getinfo(L1, options, &ar))
119 return luaL_argerror(L, arg+2, "invalid option");
120 lua_createtable(L, 0, 2);
121 if (strchr(options, 'S')) {
122 settabss(L, "source", ar.source);
123 settabss(L, "short_src", ar.short_src);
124 settabsi(L, "linedefined", ar.linedefined);
125 settabsi(L, "lastlinedefined", ar.lastlinedefined);
126 settabss(L, "what", ar.what);
127 }
128 if (strchr(options, 'l'))
129 settabsi(L, "currentline", ar.currentline);
130 if (strchr(options, 'u'))
131 settabsi(L, "nups", ar.nups);
132 if (strchr(options, 'n')) {
133 settabss(L, "name", ar.name);
134 settabss(L, "namewhat", ar.namewhat);
135 }
136 if (strchr(options, 'L'))
137 treatstackoption(L, L1, "activelines");
138 if (strchr(options, 'f'))
139 treatstackoption(L, L1, "func");
140 return 1; /* return table */
141}
142
143
144static int db_getlocal (lua_State *L) {
145 int arg;
146 lua_State *L1 = getthread(L, &arg);
147 lua_Debug ar;
148 const char *name;
149 if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */
150 return luaL_argerror(L, arg+1, "level out of range");
151 name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));
152 if (name) {
153 lua_xmove(L1, L, 1);
154 lua_pushstring(L, name);
155 lua_pushvalue(L, -2);
156 return 2;
157 }
158 else {
159 lua_pushnil(L);
160 return 1;
161 }
162}
163
164
165static int db_setlocal (lua_State *L) {
166 int arg;
167 lua_State *L1 = getthread(L, &arg);
168 lua_Debug ar;
169 if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */
170 return luaL_argerror(L, arg+1, "level out of range");
171 luaL_checkany(L, arg+3);
172 lua_settop(L, arg+3);
173 lua_xmove(L, L1, 1);
174 lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));
175 return 1;
176}
177
178
179static int auxupvalue (lua_State *L, int get) {
180 const char *name;
181 int n = luaL_checkint(L, 2);
182 luaL_checktype(L, 1, LUA_TFUNCTION);
183 if (lua_iscfunction(L, 1)) return 0; /* cannot touch C upvalues from Lua */
184 name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
185 if (name == NULL) return 0;
186 lua_pushstring(L, name);
187 lua_insert(L, -(get+1));
188 return get + 1;
189}
190
191
192static int db_getupvalue (lua_State *L) {
193 return auxupvalue(L, 1);
194}
195
196
197static int db_setupvalue (lua_State *L) {
198 luaL_checkany(L, 3);
199 return auxupvalue(L, 0);
200}
201
202
203
204static const char KEY_HOOK = 'h';
205
206
207static void hookf (lua_State *L, lua_Debug *ar) {
208 static const char *const hooknames[] =
209 {"call", "return", "line", "count", "tail return"};
210 lua_pushlightuserdata(L, (void *)&KEY_HOOK);
211 lua_rawget(L, LUA_REGISTRYINDEX);
212 lua_pushlightuserdata(L, L);
213 lua_rawget(L, -2);
214 if (lua_isfunction(L, -1)) {
215 lua_pushstring(L, hooknames[(int)ar->event]);
216 if (ar->currentline >= 0)
217 lua_pushinteger(L, ar->currentline);
218 else lua_pushnil(L);
219 lua_assert(lua_getinfo(L, "lS", ar));
220 lua_call(L, 2, 0);
221 }
222}
223
224
225static int makemask (const char *smask, int count) {
226 int mask = 0;
227 if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
228 if (strchr(smask, 'r')) mask |= LUA_MASKRET;
229 if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
230 if (count > 0) mask |= LUA_MASKCOUNT;
231 return mask;
232}
233
234
235static char *unmakemask (int mask, char *smask) {
236 int i = 0;
237 if (mask & LUA_MASKCALL) smask[i++] = 'c';
238 if (mask & LUA_MASKRET) smask[i++] = 'r';
239 if (mask & LUA_MASKLINE) smask[i++] = 'l';
240 smask[i] = '\0';
241 return smask;
242}
243
244
245static void gethooktable (lua_State *L) {
246 lua_pushlightuserdata(L, (void *)&KEY_HOOK);
247 lua_rawget(L, LUA_REGISTRYINDEX);
248 if (!lua_istable(L, -1)) {
249 lua_pop(L, 1);
250 lua_createtable(L, 0, 1);
251 lua_pushlightuserdata(L, (void *)&KEY_HOOK);
252 lua_pushvalue(L, -2);
253 lua_rawset(L, LUA_REGISTRYINDEX);
254 }
255}
256
257
258static int db_sethook (lua_State *L) {
259 int arg, mask, count;
260 lua_Hook func;
261 lua_State *L1 = getthread(L, &arg);
262 if (lua_isnoneornil(L, arg+1)) {
263 lua_settop(L, arg+1);
264 func = NULL; mask = 0; count = 0; /* turn off hooks */
265 }
266 else {
267 const char *smask = luaL_checkstring(L, arg+2);
268 luaL_checktype(L, arg+1, LUA_TFUNCTION);
269 count = luaL_optint(L, arg+3, 0);
270 func = hookf; mask = makemask(smask, count);
271 }
272 gethooktable(L);
273 lua_pushlightuserdata(L, L1);
274 lua_pushvalue(L, arg+1);
275 lua_rawset(L, -3); /* set new hook */
276 lua_pop(L, 1); /* remove hook table */
277 lua_sethook(L1, func, mask, count); /* set hooks */
278 return 0;
279}
280
281
282static int db_gethook (lua_State *L) {
283 int arg;
284 lua_State *L1 = getthread(L, &arg);
285 char buff[5];
286 int mask = lua_gethookmask(L1);
287 lua_Hook hook = lua_gethook(L1);
288 if (hook != NULL && hook != hookf) /* external hook? */
289 lua_pushliteral(L, "external hook");
290 else {
291 gethooktable(L);
292 lua_pushlightuserdata(L, L1);
293 lua_rawget(L, -2); /* get hook */
294 lua_remove(L, -2); /* remove hook table */
295 }
296 lua_pushstring(L, unmakemask(mask, buff));
297 lua_pushinteger(L, lua_gethookcount(L1));
298 return 3;
299}
300
301
302static int db_debug (lua_State *L) {
303 for (;;) {
304 char buffer[250];
305 fputs("lua_debug> ", stderr);
306 if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
307 strcmp(buffer, "cont\n") == 0)
308 return 0;
309 if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
310 lua_pcall(L, 0, 0, 0)) {
311 fputs(lua_tostring(L, -1), stderr);
312 fputs("\n", stderr);
313 }
314 lua_settop(L, 0); /* remove eventual returns */
315 }
316}
317
318
319#define LEVELS1 12 /* size of the first part of the stack */
320#define LEVELS2 10 /* size of the second part of the stack */
321
322static int db_errorfb (lua_State *L) {
323 int level;
324 int firstpart = 1; /* still before eventual `...' */
325 int arg;
326 lua_State *L1 = getthread(L, &arg);
327 lua_Debug ar;
328 if (lua_isnumber(L, arg+2)) {
329 level = (int)lua_tointeger(L, arg+2);
330 lua_pop(L, 1);
331 }
332 else
333 level = (L == L1) ? 1 : 0; /* level 0 may be this own function */
334 if (lua_gettop(L) == arg)
335 lua_pushliteral(L, "");
336 else if (!lua_isstring(L, arg+1)) return 1; /* message is not a string */
337 else lua_pushliteral(L, "\n");
338 lua_pushliteral(L, "stack traceback:");
339 while (lua_getstack(L1, level++, &ar)) {
340 if (level > LEVELS1 && firstpart) {
341 /* no more than `LEVELS2' more levels? */
342 if (!lua_getstack(L1, level+LEVELS2, &ar))
343 level--; /* keep going */
344 else {
345 lua_pushliteral(L, "\n\t..."); /* too many levels */
346 while (lua_getstack(L1, level+LEVELS2, &ar)) /* find last levels */
347 level++;
348 }
349 firstpart = 0;
350 continue;
351 }
352 lua_pushliteral(L, "\n\t");
353 lua_getinfo(L1, "Snl", &ar);
354 lua_pushfstring(L, "%s:", ar.short_src);
355 if (ar.currentline > 0)
356 lua_pushfstring(L, "%d:", ar.currentline);
357 if (*ar.namewhat != '\0') /* is there a name? */
358 lua_pushfstring(L, " in function " LUA_QS, ar.name);
359 else {
360 if (*ar.what == 'm') /* main? */
361 lua_pushfstring(L, " in main chunk");
362 else if (*ar.what == 'C' || *ar.what == 't')
363 lua_pushliteral(L, " ?"); /* C function or tail call */
364 else
365 lua_pushfstring(L, " in function <%s:%d>",
366 ar.short_src, ar.linedefined);
367 }
368 lua_concat(L, lua_gettop(L) - arg);
369 }
370 lua_concat(L, lua_gettop(L) - arg);
371 return 1;
372}
373
374
375static const luaL_Reg dblib[] = {
376 {"debug", db_debug},
377 {"getfenv", db_getfenv},
378 {"gethook", db_gethook},
379 {"getinfo", db_getinfo},
380 {"getlocal", db_getlocal},
381 {"getregistry", db_getregistry},
382 {"getmetatable", db_getmetatable},
383 {"getupvalue", db_getupvalue},
384 {"setfenv", db_setfenv},
385 {"sethook", db_sethook},
386 {"setlocal", db_setlocal},
387 {"setmetatable", db_setmetatable},
388 {"setupvalue", db_setupvalue},
389 {"traceback", db_errorfb},
390 {NULL, NULL}
391};
392
393
394LUALIB_API int luaopen_debug (lua_State *L) {
395 luaL_register(L, LUA_DBLIBNAME, dblib);
396 return 1;
397}
398
diff --git a/libraries/LuaJIT-1.1.7/src/ldebug.c b/libraries/LuaJIT-1.1.7/src/ldebug.c
new file mode 100644
index 0000000..89891fd
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldebug.c
@@ -0,0 +1,640 @@
1/*
2** $Id: ldebug.c,v 2.29.1.6 2008/05/08 16:56:26 roberto Exp $
3** Debug Interface
4** See Copyright Notice in lua.h
5*/
6
7
8#include <stdarg.h>
9#include <stddef.h>
10#include <string.h>
11
12
13#define ldebug_c
14#define LUA_CORE
15
16#include "lua.h"
17
18#include "lapi.h"
19#include "lcode.h"
20#include "ldebug.h"
21#include "ldo.h"
22#include "lfunc.h"
23#include "lobject.h"
24#include "lopcodes.h"
25#include "lstate.h"
26#include "lstring.h"
27#include "ltable.h"
28#include "ltm.h"
29#include "lvm.h"
30#include "ljit.h"
31
32
33
34static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name);
35
36
37static int currentpc (lua_State *L, CallInfo *ci) {
38 if (isLua(ci)) /* must be a Lua function to get current PC */
39 return luaJIT_findpc(ci_func(ci)->l.p,
40 ci==L->ci ? L->savedpc : ci->savedpc);
41 else
42 return -1;
43}
44
45
46static int currentline (lua_State *L, CallInfo *ci) {
47 int pc = currentpc(L, ci);
48 if (pc < 0)
49 return -1; /* only active lua functions have current-line information */
50 else
51 return getline(ci_func(ci)->l.p, pc);
52}
53
54
55/*
56** this function can be called asynchronous (e.g. during a signal)
57*/
58LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
59 if (func == NULL || mask == 0) { /* turn off hooks? */
60 mask = 0;
61 func = NULL;
62 }
63 L->hook = func;
64 L->basehookcount = count;
65 resethookcount(L);
66 L->hookmask = cast_byte(mask);
67 return 1;
68}
69
70
71LUA_API lua_Hook lua_gethook (lua_State *L) {
72 return L->hook;
73}
74
75
76LUA_API int lua_gethookmask (lua_State *L) {
77 return L->hookmask;
78}
79
80
81LUA_API int lua_gethookcount (lua_State *L) {
82 return L->basehookcount;
83}
84
85
86LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
87 int status;
88 CallInfo *ci;
89 lua_lock(L);
90 for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {
91 level--;
92 if (f_isLua(ci)) /* Lua function? */
93 level -= ci->tailcalls; /* skip lost tail calls */
94 }
95 if (level == 0 && ci > L->base_ci) { /* level found? */
96 status = 1;
97 ar->i_ci = cast_int(ci - L->base_ci);
98 }
99 else if (level < 0) { /* level is of a lost tail call? */
100 status = 1;
101 ar->i_ci = 0;
102 }
103 else status = 0; /* no such level */
104 lua_unlock(L);
105 return status;
106}
107
108
109static Proto *getluaproto (CallInfo *ci) {
110 return (isLua(ci) ? ci_func(ci)->l.p : NULL);
111}
112
113
114static const char *findlocal (lua_State *L, CallInfo *ci, int n) {
115 const char *name;
116 Proto *fp = getluaproto(ci);
117 if (fp && (name = luaF_getlocalname(fp, n, currentpc(L, ci))) != NULL)
118 return name; /* is a local variable in a Lua function */
119 else {
120 StkId limit = (ci == L->ci) ? L->top : (ci+1)->func;
121 if (limit - ci->base >= n && n > 0) /* is 'n' inside 'ci' stack? */
122 return "(*temporary)";
123 else
124 return NULL;
125 }
126}
127
128
129LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
130 CallInfo *ci = L->base_ci + ar->i_ci;
131 const char *name = findlocal(L, ci, n);
132 lua_lock(L);
133 if (name)
134 luaA_pushobject(L, ci->base + (n - 1));
135 lua_unlock(L);
136 return name;
137}
138
139
140LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
141 CallInfo *ci = L->base_ci + ar->i_ci;
142 const char *name = findlocal(L, ci, n);
143 lua_lock(L);
144 if (name)
145 setobjs2s(L, ci->base + (n - 1), L->top - 1);
146 L->top--; /* pop value */
147 lua_unlock(L);
148 return name;
149}
150
151
152static void funcinfo (lua_Debug *ar, Closure *cl) {
153 if (cl->c.isC) {
154 ar->source = "=[C]";
155 ar->linedefined = -1;
156 ar->lastlinedefined = -1;
157 ar->what = "C";
158 }
159 else {
160 ar->source = getstr(cl->l.p->source);
161 ar->linedefined = cl->l.p->linedefined;
162 ar->lastlinedefined = cl->l.p->lastlinedefined;
163 ar->what = (ar->linedefined == 0) ? "main" : "Lua";
164 }
165 luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
166}
167
168
169static void info_tailcall (lua_Debug *ar) {
170 ar->name = ar->namewhat = "";
171 ar->what = "tail";
172 ar->lastlinedefined = ar->linedefined = ar->currentline = -1;
173 ar->source = "=(tail call)";
174 luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
175 ar->nups = 0;
176}
177
178
179static void collectvalidlines (lua_State *L, Closure *f) {
180 if (f == NULL || f->c.isC) {
181 setnilvalue(L->top);
182 }
183 else {
184 Table *t = luaH_new(L, 0, 0);
185 int *lineinfo = f->l.p->lineinfo;
186 int i;
187 for (i=0; i<f->l.p->sizelineinfo; i++)
188 setbvalue(luaH_setnum(L, t, lineinfo[i]), 1);
189 sethvalue(L, L->top, t);
190 }
191 incr_top(L);
192}
193
194
195static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
196 Closure *f, CallInfo *ci) {
197 int status = 1;
198 if (f == NULL) {
199 info_tailcall(ar);
200 return status;
201 }
202 for (; *what; what++) {
203 switch (*what) {
204 case 'S': {
205 funcinfo(ar, f);
206 break;
207 }
208 case 'l': {
209 ar->currentline = (ci) ? currentline(L, ci) : -1;
210 break;
211 }
212 case 'u': {
213 ar->nups = f->c.nupvalues;
214 break;
215 }
216 case 'n': {
217 ar->namewhat = (ci) ? getfuncname(L, ci, &ar->name) : NULL;
218 if (ar->namewhat == NULL) {
219 ar->namewhat = ""; /* not found */
220 ar->name = NULL;
221 }
222 break;
223 }
224 case 'L':
225 case 'f': /* handled by lua_getinfo */
226 break;
227 default: status = 0; /* invalid option */
228 }
229 }
230 return status;
231}
232
233
234LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
235 int status;
236 Closure *f = NULL;
237 CallInfo *ci = NULL;
238 lua_lock(L);
239 if (*what == '>') {
240 StkId func = L->top - 1;
241 luai_apicheck(L, ttisfunction(func));
242 what++; /* skip the '>' */
243 f = clvalue(func);
244 L->top--; /* pop function */
245 }
246 else if (ar->i_ci != 0) { /* no tail call? */
247 ci = L->base_ci + ar->i_ci;
248 lua_assert(ttisfunction(ci->func));
249 f = clvalue(ci->func);
250 }
251 status = auxgetinfo(L, what, ar, f, ci);
252 if (strchr(what, 'f')) {
253 if (f == NULL) setnilvalue(L->top);
254 else setclvalue(L, L->top, f);
255 incr_top(L);
256 }
257 if (strchr(what, 'L'))
258 collectvalidlines(L, f);
259 lua_unlock(L);
260 return status;
261}
262
263
264/*
265** {======================================================
266** Symbolic Execution and code checker
267** =======================================================
268*/
269
270#define check(x) if (!(x)) return 0;
271
272#define checkjump(pt,pc) check(0 <= pc && pc < pt->sizecode)
273
274#define checkreg(pt,reg) check((reg) < (pt)->maxstacksize)
275
276
277
278static int precheck (const Proto *pt) {
279 check(pt->maxstacksize <= MAXSTACK);
280 check(pt->numparams+(pt->is_vararg & VARARG_HASARG) <= pt->maxstacksize);
281 check(!(pt->is_vararg & VARARG_NEEDSARG) ||
282 (pt->is_vararg & VARARG_HASARG));
283 check(pt->sizeupvalues <= pt->nups);
284 check(pt->sizelineinfo == pt->sizecode || pt->sizelineinfo == 0);
285 check(pt->sizecode > 0 && GET_OPCODE(pt->code[pt->sizecode-1]) == OP_RETURN);
286 return 1;
287}
288
289
290#define checkopenop(pt,pc) luaG_checkopenop((pt)->code[(pc)+1])
291
292int luaG_checkopenop (Instruction i) {
293 switch (GET_OPCODE(i)) {
294 case OP_CALL:
295 case OP_TAILCALL:
296 case OP_RETURN:
297 case OP_SETLIST: {
298 check(GETARG_B(i) == 0);
299 return 1;
300 }
301 default: return 0; /* invalid instruction after an open call */
302 }
303}
304
305
306static int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) {
307 switch (mode) {
308 case OpArgN: check(r == 0); break;
309 case OpArgU: break;
310 case OpArgR: checkreg(pt, r); break;
311 case OpArgK:
312 check(ISK(r) ? INDEXK(r) < pt->sizek : r < pt->maxstacksize);
313 break;
314 }
315 return 1;
316}
317
318
319static Instruction symbexec (const Proto *pt, int lastpc, int reg) {
320 int pc;
321 int last; /* stores position of last instruction that changed `reg' */
322 last = pt->sizecode-1; /* points to final return (a `neutral' instruction) */
323 check(precheck(pt));
324 for (pc = 0; pc < lastpc; pc++) {
325 Instruction i = pt->code[pc];
326 OpCode op = GET_OPCODE(i);
327 int a = GETARG_A(i);
328 int b = 0;
329 int c = 0;
330 check(op < NUM_OPCODES);
331 checkreg(pt, a);
332 switch (getOpMode(op)) {
333 case iABC: {
334 b = GETARG_B(i);
335 c = GETARG_C(i);
336 check(checkArgMode(pt, b, getBMode(op)));
337 check(checkArgMode(pt, c, getCMode(op)));
338 break;
339 }
340 case iABx: {
341 b = GETARG_Bx(i);
342 if (getBMode(op) == OpArgK) check(b < pt->sizek);
343 break;
344 }
345 case iAsBx: {
346 b = GETARG_sBx(i);
347 if (getBMode(op) == OpArgR) {
348 int dest = pc+1+b;
349 check(0 <= dest && dest < pt->sizecode);
350 if (dest > 0) {
351 int j;
352 /* check that it does not jump to a setlist count; this
353 is tricky, because the count from a previous setlist may
354 have the same value of an invalid setlist; so, we must
355 go all the way back to the first of them (if any) */
356 for (j = 0; j < dest; j++) {
357 Instruction d = pt->code[dest-1-j];
358 if (!(GET_OPCODE(d) == OP_SETLIST && GETARG_C(d) == 0)) break;
359 }
360 /* if 'j' is even, previous value is not a setlist (even if
361 it looks like one) */
362 check((j&1) == 0);
363 }
364 }
365 break;
366 }
367 }
368 if (testAMode(op)) {
369 if (a == reg) last = pc; /* change register `a' */
370 }
371 if (testTMode(op)) {
372 check(pc+2 < pt->sizecode); /* check skip */
373 check(GET_OPCODE(pt->code[pc+1]) == OP_JMP);
374 }
375 switch (op) {
376 case OP_LOADBOOL: {
377 if (c == 1) { /* does it jump? */
378 check(pc+2 < pt->sizecode); /* check its jump */
379 check(GET_OPCODE(pt->code[pc+1]) != OP_SETLIST ||
380 GETARG_C(pt->code[pc+1]) != 0);
381 }
382 break;
383 }
384 case OP_LOADNIL: {
385 if (a <= reg && reg <= b)
386 last = pc; /* set registers from `a' to `b' */
387 break;
388 }
389 case OP_GETUPVAL:
390 case OP_SETUPVAL: {
391 check(b < pt->nups);
392 break;
393 }
394 case OP_GETGLOBAL:
395 case OP_SETGLOBAL: {
396 check(ttisstring(&pt->k[b]));
397 break;
398 }
399 case OP_SELF: {
400 checkreg(pt, a+1);
401 if (reg == a+1) last = pc;
402 break;
403 }
404 case OP_CONCAT: {
405 check(b < c); /* at least two operands */
406 break;
407 }
408 case OP_TFORLOOP: {
409 check(c >= 1); /* at least one result (control variable) */
410 checkreg(pt, a+2+c); /* space for results */
411 if (reg >= a+2) last = pc; /* affect all regs above its base */
412 break;
413 }
414 case OP_FORLOOP:
415 case OP_FORPREP:
416 checkreg(pt, a+3);
417 /* go through */
418 case OP_JMP: {
419 int dest = pc+1+b;
420 /* not full check and jump is forward and do not skip `lastpc'? */
421 if (reg != NO_REG && pc < dest && dest <= lastpc)
422 pc += b; /* do the jump */
423 break;
424 }
425 case OP_CALL:
426 case OP_TAILCALL: {
427 if (b != 0) {
428 checkreg(pt, a+b-1);
429 }
430 c--; /* c = num. returns */
431 if (c == LUA_MULTRET) {
432 check(checkopenop(pt, pc));
433 }
434 else if (c != 0)
435 checkreg(pt, a+c-1);
436 if (reg >= a) last = pc; /* affect all registers above base */
437 break;
438 }
439 case OP_RETURN: {
440 b--; /* b = num. returns */
441 if (b > 0) checkreg(pt, a+b-1);
442 break;
443 }
444 case OP_SETLIST: {
445 if (b > 0) checkreg(pt, a + b);
446 if (c == 0) {
447 pc++;
448 check(pc < pt->sizecode - 1);
449 }
450 break;
451 }
452 case OP_CLOSURE: {
453 int nup, j;
454 check(b < pt->sizep);
455 nup = pt->p[b]->nups;
456 check(pc + nup < pt->sizecode);
457 for (j = 1; j <= nup; j++) {
458 OpCode op1 = GET_OPCODE(pt->code[pc + j]);
459 check(op1 == OP_GETUPVAL || op1 == OP_MOVE);
460 }
461 if (reg != NO_REG) /* tracing? */
462 pc += nup; /* do not 'execute' these pseudo-instructions */
463 break;
464 }
465 case OP_VARARG: {
466 check((pt->is_vararg & VARARG_ISVARARG) &&
467 !(pt->is_vararg & VARARG_NEEDSARG));
468 b--;
469 if (b == LUA_MULTRET) check(checkopenop(pt, pc));
470 checkreg(pt, a+b-1);
471 break;
472 }
473 default: break;
474 }
475 }
476 return pt->code[last];
477}
478
479#undef check
480#undef checkjump
481#undef checkreg
482
483/* }====================================================== */
484
485
486int luaG_checkcode (const Proto *pt) {
487 return (symbexec(pt, pt->sizecode, NO_REG) != 0);
488}
489
490
491static const char *kname (Proto *p, int c) {
492 if (ISK(c) && ttisstring(&p->k[INDEXK(c)]))
493 return svalue(&p->k[INDEXK(c)]);
494 else
495 return "?";
496}
497
498
499static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,
500 const char **name) {
501 if (isLua(ci)) { /* a Lua function? */
502 Proto *p = ci_func(ci)->l.p;
503 int pc = currentpc(L, ci);
504 Instruction i;
505 *name = luaF_getlocalname(p, stackpos+1, pc);
506 if (*name) /* is a local? */
507 return "local";
508 i = symbexec(p, pc, stackpos); /* try symbolic execution */
509 lua_assert(pc != -1);
510 switch (GET_OPCODE(i)) {
511 case OP_GETGLOBAL: {
512 int g = GETARG_Bx(i); /* global index */
513 lua_assert(ttisstring(&p->k[g]));
514 *name = svalue(&p->k[g]);
515 return "global";
516 }
517 case OP_MOVE: {
518 int a = GETARG_A(i);
519 int b = GETARG_B(i); /* move from `b' to `a' */
520 if (b < a)
521 return getobjname(L, ci, b, name); /* get name for `b' */
522 break;
523 }
524 case OP_GETTABLE: {
525 int k = GETARG_C(i); /* key index */
526 *name = kname(p, k);
527 return "field";
528 }
529 case OP_GETUPVAL: {
530 int u = GETARG_B(i); /* upvalue index */
531 *name = p->upvalues ? getstr(p->upvalues[u]) : "?";
532 return "upvalue";
533 }
534 case OP_SELF: {
535 int k = GETARG_C(i); /* key index */
536 *name = kname(p, k);
537 return "method";
538 }
539 default: break;
540 }
541 }
542 return NULL; /* no useful name found */
543}
544
545
546static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
547 Instruction i;
548 if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))
549 return NULL; /* calling function is not Lua (or is unknown) */
550 ci--; /* calling function */
551 i = ci_func(ci)->l.p->code[currentpc(L, ci)];
552 if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
553 GET_OPCODE(i) == OP_TFORLOOP)
554 return getobjname(L, ci, GETARG_A(i), name);
555 else
556 return NULL; /* no useful name can be found */
557}
558
559
560/* only ANSI way to check whether a pointer points to an array */
561static int isinstack (CallInfo *ci, const TValue *o) {
562 StkId p;
563 for (p = ci->base; p < ci->top; p++)
564 if (o == p) return 1;
565 return 0;
566}
567
568
569void luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
570 const char *name = NULL;
571 const char *t = luaT_typenames[ttype(o)];
572 const char *kind = (isinstack(L->ci, o)) ?
573 getobjname(L, L->ci, cast_int(o - L->base), &name) :
574 NULL;
575 if (kind)
576 luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",
577 op, kind, name, t);
578 else
579 luaG_runerror(L, "attempt to %s a %s value", op, t);
580}
581
582
583void luaG_concaterror (lua_State *L, StkId p1, StkId p2) {
584 if (ttisstring(p1) || ttisnumber(p1)) p1 = p2;
585 lua_assert(!ttisstring(p1) && !ttisnumber(p1));
586 luaG_typeerror(L, p1, "concatenate");
587}
588
589
590void luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {
591 TValue temp;
592 if (luaV_tonumber(p1, &temp) == NULL)
593 p2 = p1; /* first operand is wrong */
594 luaG_typeerror(L, p2, "perform arithmetic on");
595}
596
597
598int luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
599 const char *t1 = luaT_typenames[ttype(p1)];
600 const char *t2 = luaT_typenames[ttype(p2)];
601 if (t1[2] == t2[2])
602 luaG_runerror(L, "attempt to compare two %s values", t1);
603 else
604 luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
605 return 0;
606}
607
608
609static void addinfo (lua_State *L, const char *msg) {
610 CallInfo *ci = L->ci;
611 if (isLua(ci)) { /* is Lua code? */
612 char buff[LUA_IDSIZE]; /* add file:line information */
613 int line = currentline(L, ci);
614 luaO_chunkid(buff, getstr(getluaproto(ci)->source), LUA_IDSIZE);
615 luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
616 }
617}
618
619
620void luaG_errormsg (lua_State *L) {
621 if (L->errfunc != 0) { /* is there an error handling function? */
622 StkId errfunc = restorestack(L, L->errfunc);
623 if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);
624 setobjs2s(L, L->top, L->top - 1); /* move argument */
625 setobjs2s(L, L->top - 1, errfunc); /* push function */
626 incr_top(L);
627 luaD_call(L, L->top - 2, 1); /* call it */
628 }
629 luaD_throw(L, LUA_ERRRUN);
630}
631
632
633void luaG_runerror (lua_State *L, const char *fmt, ...) {
634 va_list argp;
635 va_start(argp, fmt);
636 addinfo(L, luaO_pushvfstring(L, fmt, argp));
637 va_end(argp);
638 luaG_errormsg(L);
639}
640
diff --git a/libraries/LuaJIT-1.1.7/src/ldebug.h b/libraries/LuaJIT-1.1.7/src/ldebug.h
new file mode 100644
index 0000000..ba28a97
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldebug.h
@@ -0,0 +1,33 @@
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
21LUAI_FUNC void luaG_typeerror (lua_State *L, const TValue *o,
22 const char *opname);
23LUAI_FUNC void luaG_concaterror (lua_State *L, StkId p1, StkId p2);
24LUAI_FUNC void luaG_aritherror (lua_State *L, const TValue *p1,
25 const TValue *p2);
26LUAI_FUNC int luaG_ordererror (lua_State *L, const TValue *p1,
27 const TValue *p2);
28LUAI_FUNC void luaG_runerror (lua_State *L, const char *fmt, ...);
29LUAI_FUNC void luaG_errormsg (lua_State *L);
30LUAI_FUNC int luaG_checkcode (const Proto *pt);
31LUAI_FUNC int luaG_checkopenop (Instruction i);
32
33#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ldo.c b/libraries/LuaJIT-1.1.7/src/ldo.c
new file mode 100644
index 0000000..1d9393d
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldo.c
@@ -0,0 +1,519 @@
1/*
2** $Id: ldo.c,v 2.38.1.3 2008/01/18 22:31:22 roberto Exp $
3** Stack and Call structure of Lua
4** See Copyright Notice in lua.h
5*/
6
7
8#include <setjmp.h>
9#include <stdlib.h>
10#include <string.h>
11
12#define ldo_c
13#define LUA_CORE
14
15#include "lua.h"
16
17#include "ldebug.h"
18#include "ldo.h"
19#include "lfunc.h"
20#include "lgc.h"
21#include "lmem.h"
22#include "lobject.h"
23#include "lopcodes.h"
24#include "lparser.h"
25#include "lstate.h"
26#include "lstring.h"
27#include "ltable.h"
28#include "ltm.h"
29#include "lundump.h"
30#include "lvm.h"
31#include "lzio.h"
32#include "ljit.h"
33
34
35
36
37/*
38** {======================================================
39** Error-recovery functions
40** =======================================================
41*/
42
43
44/* chain list of long jump buffers */
45struct lua_longjmp {
46 struct lua_longjmp *previous;
47 luai_jmpbuf b;
48 volatile int status; /* error code */
49};
50
51
52void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {
53 switch (errcode) {
54 case LUA_ERRMEM: {
55 setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
56 break;
57 }
58 case LUA_ERRERR: {
59 setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
60 break;
61 }
62 case LUA_ERRSYNTAX:
63 case LUA_ERRRUN: {
64 setobjs2s(L, oldtop, L->top - 1); /* error message on current top */
65 break;
66 }
67 }
68 L->top = oldtop + 1;
69}
70
71
72static void restore_stack_limit (lua_State *L) {
73 lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
74 if (L->size_ci > LUAI_MAXCALLS) { /* there was an overflow? */
75 int inuse = cast_int(L->ci - L->base_ci);
76 if (inuse + 1 < LUAI_MAXCALLS) /* can `undo' overflow? */
77 luaD_reallocCI(L, LUAI_MAXCALLS);
78 }
79}
80
81
82static void resetstack (lua_State *L, int status) {
83 L->ci = L->base_ci;
84 L->base = L->ci->base;
85 luaF_close(L, L->base); /* close eventual pending closures */
86 luaD_seterrorobj(L, status, L->base);
87 L->nCcalls = 0;
88 L->allowhook = 1;
89 restore_stack_limit(L);
90 L->errfunc = 0;
91 L->errorJmp = NULL;
92}
93
94
95void luaD_throw (lua_State *L, int errcode) {
96 if (L->errorJmp) {
97 L->errorJmp->status = errcode;
98 LUAI_THROW(L, L->errorJmp);
99 }
100 else {
101 L->status = cast_byte(errcode);
102 if (G(L)->panic) {
103 resetstack(L, errcode);
104 lua_unlock(L);
105 G(L)->panic(L);
106 }
107 exit(EXIT_FAILURE);
108 }
109}
110
111
112int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
113 struct lua_longjmp lj;
114 lj.status = 0;
115 lj.previous = L->errorJmp; /* chain new error handler */
116 L->errorJmp = &lj;
117 LUAI_TRY(L, &lj,
118 (*f)(L, ud);
119 );
120 L->errorJmp = lj.previous; /* restore old error handler */
121 return lj.status;
122}
123
124/* }====================================================== */
125
126
127static void correctstack (lua_State *L, TValue *oldstack) {
128 CallInfo *ci;
129 GCObject *up;
130 L->top = (L->top - oldstack) + L->stack;
131 for (up = L->openupval; up != NULL; up = up->gch.next)
132 gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;
133 for (ci = L->base_ci; ci <= L->ci; ci++) {
134 ci->top = (ci->top - oldstack) + L->stack;
135 ci->base = (ci->base - oldstack) + L->stack;
136 ci->func = (ci->func - oldstack) + L->stack;
137 }
138 L->base = (L->base - oldstack) + L->stack;
139}
140
141
142void luaD_reallocstack (lua_State *L, int newsize) {
143 TValue *oldstack = L->stack;
144 int realsize = newsize + 1 + EXTRA_STACK;
145 lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
146 luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);
147 L->stacksize = realsize;
148 L->stack_last = L->stack+newsize;
149 correctstack(L, oldstack);
150}
151
152
153void luaD_reallocCI (lua_State *L, int newsize) {
154 CallInfo *oldci = L->base_ci;
155 luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);
156 L->size_ci = newsize;
157 L->ci = (L->ci - oldci) + L->base_ci;
158 L->end_ci = L->base_ci + L->size_ci - 1;
159}
160
161
162void luaD_growstack (lua_State *L, int n) {
163 if (n <= L->stacksize) /* double size is enough? */
164 luaD_reallocstack(L, 2*L->stacksize);
165 else
166 luaD_reallocstack(L, L->stacksize + n);
167}
168
169
170CallInfo *luaD_growCI (lua_State *L) {
171 if (L->size_ci > LUAI_MAXCALLS) /* overflow while handling overflow? */
172 luaD_throw(L, LUA_ERRERR);
173 else {
174 luaD_reallocCI(L, 2*L->size_ci);
175 if (L->size_ci > LUAI_MAXCALLS)
176 luaG_runerror(L, "stack overflow");
177 }
178 return ++L->ci;
179}
180
181
182void luaD_callhook (lua_State *L, int event, int line) {
183 lua_Hook hook = L->hook;
184 if (hook && L->allowhook) {
185 ptrdiff_t top = savestack(L, L->top);
186 ptrdiff_t ci_top = savestack(L, L->ci->top);
187 lua_Debug ar;
188 ar.event = event;
189 ar.currentline = line;
190 if (event == LUA_HOOKTAILRET)
191 ar.i_ci = 0; /* tail call; no debug information about it */
192 else
193 ar.i_ci = cast_int(L->ci - L->base_ci);
194 luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
195 L->ci->top = L->top + LUA_MINSTACK;
196 lua_assert(L->ci->top <= L->stack_last);
197 L->allowhook = 0; /* cannot call hooks inside a hook */
198 lua_unlock(L);
199 (*hook)(L, &ar);
200 lua_lock(L);
201 lua_assert(!L->allowhook);
202 L->allowhook = 1;
203 L->ci->top = restorestack(L, ci_top);
204 L->top = restorestack(L, top);
205 }
206}
207
208
209static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
210 int i;
211 int nfixargs = p->numparams;
212 Table *htab = NULL;
213 StkId base, fixed;
214 for (; actual < nfixargs; ++actual)
215 setnilvalue(L->top++);
216#if defined(LUA_COMPAT_VARARG)
217 if (p->is_vararg & VARARG_NEEDSARG) { /* compat. with old-style vararg? */
218 int nvar = actual - nfixargs; /* number of extra arguments */
219 lua_assert(p->is_vararg & VARARG_HASARG);
220 luaC_checkGC(L);
221 htab = luaH_new(L, nvar, 1); /* create `arg' table */
222 for (i=0; i<nvar; i++) /* put extra arguments into `arg' table */
223 setobj2n(L, luaH_setnum(L, htab, i+1), L->top - nvar + i);
224 /* store counter in field `n' */
225 setnvalue(luaH_setstr(L, htab, luaS_newliteral(L, "n")), cast_num(nvar));
226 }
227#endif
228 /* move fixed parameters to final position */
229 fixed = L->top - actual; /* first fixed argument */
230 base = L->top; /* final position of first argument */
231 for (i=0; i<nfixargs; i++) {
232 setobjs2s(L, L->top++, fixed+i);
233 setnilvalue(fixed+i);
234 }
235 /* add `arg' parameter */
236 if (htab) {
237 sethvalue(L, L->top++, htab);
238 lua_assert(iswhite(obj2gco(htab)));
239 }
240 return base;
241}
242
243
244StkId luaD_tryfuncTM (lua_State *L, StkId func) {
245 const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
246 StkId p;
247 ptrdiff_t funcr = savestack(L, func);
248 if (!ttisfunction(tm))
249 luaG_typeerror(L, func, "call");
250 /* Open a hole inside the stack at `func' */
251 for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);
252 incr_top(L);
253 func = restorestack(L, funcr); /* previous call may change stack */
254 setobj2s(L, func, tm); /* tag method is the new function to be called */
255 return func;
256}
257
258
259
260#define inc_ci(L) \
261 ((L->ci == L->end_ci) ? luaD_growCI(L) : \
262 (condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))
263
264
265int luaD_precall (lua_State *L, StkId func, int nresults) {
266 LClosure *cl;
267 ptrdiff_t funcr;
268 if (!ttisfunction(func)) /* `func' is not a function? */
269 func = luaD_tryfuncTM(L, func); /* check the `function' tag method */
270 funcr = savestack(L, func);
271 cl = &clvalue(func)->l;
272 L->ci->savedpc = L->savedpc;
273 if (!cl->isC) { /* Lua function? prepare its call */
274 CallInfo *ci;
275 StkId st, base;
276 Proto *p = cl->p;
277 if (p->jit_status <= JIT_S_NONE) { /* JIT compiler enabled? */
278 if (p->jit_status == JIT_S_OK)
279 return G(L)->jit_gateLJ(L, func, nresults); /* Run compiled code. */
280 else
281 return luaJIT_run(L, func, nresults); /* Compile and run code. */
282 }
283 luaD_checkstack(L, p->maxstacksize);
284 func = restorestack(L, funcr);
285 if (!p->is_vararg) { /* no varargs? */
286 base = func + 1;
287 if (L->top > base + p->numparams)
288 L->top = base + p->numparams;
289 }
290 else { /* vararg function */
291 int nargs = cast_int(L->top - func) - 1;
292 base = adjust_varargs(L, p, nargs);
293 func = restorestack(L, funcr); /* previous call may change the stack */
294 }
295 ci = inc_ci(L); /* now `enter' new function */
296 ci->func = func;
297 L->base = ci->base = base;
298 ci->top = L->base + p->maxstacksize;
299 lua_assert(ci->top <= L->stack_last);
300 L->savedpc = p->code; /* starting point */
301 ci->tailcalls = 0;
302 ci->nresults = nresults;
303 for (st = L->top; st < ci->top; st++)
304 setnilvalue(st);
305 L->top = ci->top;
306 if (L->hookmask & LUA_MASKCALL) {
307 L->savedpc++; /* hooks assume 'pc' is already incremented */
308 luaD_callhook(L, LUA_HOOKCALL, -1);
309 L->savedpc--; /* correct 'pc' */
310 }
311 return PCRLUA;
312 }
313 else { /* if is a C function, call it */
314 CallInfo *ci;
315 int n;
316 luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
317 ci = inc_ci(L); /* now `enter' new function */
318 ci->func = restorestack(L, funcr);
319 L->base = ci->base = ci->func + 1;
320 ci->top = L->top + LUA_MINSTACK;
321 lua_assert(ci->top <= L->stack_last);
322 ci->nresults = nresults;
323 if (L->hookmask & LUA_MASKCALL)
324 luaD_callhook(L, LUA_HOOKCALL, -1);
325 lua_unlock(L);
326 n = (*curr_func(L)->c.f)(L); /* do the actual call */
327 lua_lock(L);
328 if (n < 0) /* yielding? */
329 return PCRYIELD;
330 else {
331 luaD_poscall(L, L->top - n);
332 return PCRC;
333 }
334 }
335}
336
337
338static StkId callrethooks (lua_State *L, StkId firstResult) {
339 ptrdiff_t fr = savestack(L, firstResult); /* next call may change stack */
340 luaD_callhook(L, LUA_HOOKRET, -1);
341 if (f_isLua(L->ci)) { /* Lua function? */
342 while ((L->hookmask & LUA_MASKRET) && L->ci->tailcalls--) /* tail calls */
343 luaD_callhook(L, LUA_HOOKTAILRET, -1);
344 }
345 return restorestack(L, fr);
346}
347
348
349int luaD_poscall (lua_State *L, StkId firstResult) {
350 StkId res;
351 int wanted, i;
352 CallInfo *ci;
353 if (L->hookmask & LUA_MASKRET)
354 firstResult = callrethooks(L, firstResult);
355 ci = L->ci--;
356 res = ci->func; /* res == final position of 1st result */
357 wanted = ci->nresults;
358 L->base = (ci - 1)->base; /* restore base */
359 L->savedpc = (ci - 1)->savedpc; /* restore savedpc */
360 /* move results to correct place */
361 for (i = wanted; i != 0 && firstResult < L->top; i--)
362 setobjs2s(L, res++, firstResult++);
363 while (i-- > 0)
364 setnilvalue(res++);
365 L->top = res;
366 return (wanted - LUA_MULTRET); /* 0 iff wanted == LUA_MULTRET */
367}
368
369
370/*
371** Call a function (C or Lua). The function to be called is at *func.
372** The arguments are on the stack, right after the function.
373** When returns, all the results are on the stack, starting at the original
374** function position.
375*/
376void luaD_call (lua_State *L, StkId func, int nResults) {
377 if (++L->nCcalls >= LUAI_MAXCCALLS) {
378 if (L->nCcalls == LUAI_MAXCCALLS)
379 luaG_runerror(L, "C stack overflow");
380 else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
381 luaD_throw(L, LUA_ERRERR); /* error while handing stack error */
382 }
383 if (luaD_precall(L, func, nResults) == PCRLUA) /* is a Lua function? */
384 luaV_execute(L, 1); /* call it */
385 L->nCcalls--;
386 luaC_checkGC(L);
387}
388
389
390static void resume (lua_State *L, void *ud) {
391 StkId firstArg = cast(StkId, ud);
392 CallInfo *ci = L->ci;
393 if (L->status == 0) { /* start coroutine? */
394 lua_assert(ci == L->base_ci && firstArg > L->base);
395 if (luaD_precall(L, firstArg - 1, LUA_MULTRET) != PCRLUA)
396 return;
397 }
398 else { /* resuming from previous yield */
399 lua_assert(L->status == LUA_YIELD);
400 L->status = 0;
401 if (!f_isLua(ci)) { /* `common' yield? */
402 /* finish interrupted execution of `OP_CALL' */
403 lua_assert(GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_CALL ||
404 GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_TAILCALL);
405 if (luaD_poscall(L, firstArg)) /* complete it... */
406 L->top = L->ci->top; /* and correct top if not multiple results */
407 }
408 else /* yielded inside a hook: just continue its execution */
409 L->base = L->ci->base;
410 }
411 luaV_execute(L, cast_int(L->ci - L->base_ci));
412}
413
414
415static int resume_error (lua_State *L, const char *msg) {
416 L->top = L->ci->base;
417 setsvalue2s(L, L->top, luaS_new(L, msg));
418 incr_top(L);
419 lua_unlock(L);
420 return LUA_ERRRUN;
421}
422
423
424LUA_API int lua_resume (lua_State *L, int nargs) {
425 int status;
426 lua_lock(L);
427 if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))
428 return resume_error(L, "cannot resume non-suspended coroutine");
429 luai_userstateresume(L, nargs);
430 lua_assert(L->errfunc == 0 && L->nCcalls == 0);
431 status = luaD_rawrunprotected(L, resume, L->top - nargs);
432 if (status != 0) { /* error? */
433 L->status = cast_byte(status); /* mark thread as `dead' */
434 luaD_seterrorobj(L, status, L->top);
435 L->ci->top = L->top;
436 }
437 else
438 status = L->status;
439 lua_unlock(L);
440 return status;
441}
442
443
444LUA_API int lua_yield (lua_State *L, int nresults) {
445 luai_userstateyield(L, nresults);
446 lua_lock(L);
447 if (L->nCcalls > 0)
448 luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");
449 L->base = L->top - nresults; /* protect stack slots below */
450 L->status = LUA_YIELD;
451 lua_unlock(L);
452 return -1;
453}
454
455
456int luaD_pcall (lua_State *L, Pfunc func, void *u,
457 ptrdiff_t old_top, ptrdiff_t ef) {
458 int status;
459 unsigned short oldnCcalls = L->nCcalls;
460 ptrdiff_t old_ci = saveci(L, L->ci);
461 lu_byte old_allowhooks = L->allowhook;
462 ptrdiff_t old_errfunc = L->errfunc;
463 L->errfunc = ef;
464 status = luaD_rawrunprotected(L, func, u);
465 if (status != 0) { /* an error occurred? */
466 StkId oldtop = restorestack(L, old_top);
467 luaF_close(L, oldtop); /* close eventual pending closures */
468 luaD_seterrorobj(L, status, oldtop);
469 L->nCcalls = oldnCcalls;
470 L->ci = restoreci(L, old_ci);
471 L->base = L->ci->base;
472 L->savedpc = L->ci->savedpc;
473 L->allowhook = old_allowhooks;
474 restore_stack_limit(L);
475 }
476 L->errfunc = old_errfunc;
477 return status;
478}
479
480
481
482/*
483** Execute a protected parser.
484*/
485struct SParser { /* data to `f_parser' */
486 ZIO *z;
487 Mbuffer buff; /* buffer to be used by the scanner */
488 const char *name;
489};
490
491static void f_parser (lua_State *L, void *ud) {
492 int i;
493 Proto *tf;
494 Closure *cl;
495 struct SParser *p = cast(struct SParser *, ud);
496 int c = luaZ_lookahead(p->z);
497 luaC_checkGC(L);
498 tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
499 &p->buff, p->name);
500 cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
501 cl->l.p = tf;
502 for (i = 0; i < tf->nups; i++) /* initialize eventual upvalues */
503 cl->l.upvals[i] = luaF_newupval(L);
504 setclvalue(L, L->top, cl);
505 incr_top(L);
506}
507
508
509int luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {
510 struct SParser p;
511 int status;
512 p.z = z; p.name = name;
513 luaZ_initbuffer(L, &p.buff);
514 status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
515 luaZ_freebuffer(L, &p.buff);
516 return status;
517}
518
519
diff --git a/libraries/LuaJIT-1.1.7/src/ldo.h b/libraries/LuaJIT-1.1.7/src/ldo.h
new file mode 100644
index 0000000..63760f9
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldo.h
@@ -0,0 +1,59 @@
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 function yielded */
35
36
37/* type of protected functions, to be ran by `runprotected' */
38typedef void (*Pfunc) (lua_State *L, void *ud);
39
40LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name);
41LUAI_FUNC void luaD_callhook (lua_State *L, int event, int line);
42LUAI_FUNC StkId luaD_tryfuncTM (lua_State *L, StkId func);
43LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
44LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
45LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
46 ptrdiff_t oldtop, ptrdiff_t ef);
47LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);
48LUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize);
49LUAI_FUNC CallInfo *luaD_growCI (lua_State *L);
50LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
51LUAI_FUNC void luaD_growstack (lua_State *L, int n);
52
53LUAI_FUNC void luaD_throw (lua_State *L, int errcode);
54LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
55
56LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
57
58#endif
59
diff --git a/libraries/LuaJIT-1.1.7/src/ldump.c b/libraries/LuaJIT-1.1.7/src/ldump.c
new file mode 100644
index 0000000..c9d3d48
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldump.c
@@ -0,0 +1,164 @@
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
18typedef 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
29static 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
39static void DumpChar(int y, DumpState* D)
40{
41 char x=(char)y;
42 DumpVar(x,D);
43}
44
45static void DumpInt(int x, DumpState* D)
46{
47 DumpVar(x,D);
48}
49
50static void DumpNumber(lua_Number x, DumpState* D)
51{
52 DumpVar(x,D);
53}
54
55static 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
61static 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
78static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
79
80static 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
111static 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
129static 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
143static 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*/
153int 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}
diff --git a/libraries/LuaJIT-1.1.7/src/lfunc.c b/libraries/LuaJIT-1.1.7/src/lfunc.c
new file mode 100644
index 0000000..334e305
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lfunc.c
@@ -0,0 +1,182 @@
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#include "ljit.h"
21
22
23
24Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {
25 Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
26 luaC_link(L, obj2gco(c), LUA_TFUNCTION);
27 c->c.isC = 1;
28 c->c.env = e;
29 c->c.nupvalues = cast_byte(nelems);
30 c->c.jit_gate = G(L)->jit_gateJC;
31 return c;
32}
33
34
35Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {
36 Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
37 luaC_link(L, obj2gco(c), LUA_TFUNCTION);
38 c->l.isC = 0;
39 c->l.env = e;
40 c->l.jit_gate = G(L)->jit_gateJL;
41 c->l.nupvalues = cast_byte(nelems);
42 while (nelems--) c->l.upvals[nelems] = NULL;
43 return c;
44}
45
46
47UpVal *luaF_newupval (lua_State *L) {
48 UpVal *uv = luaM_new(L, UpVal);
49 luaC_link(L, obj2gco(uv), LUA_TUPVAL);
50 uv->v = &uv->u.value;
51 setnilvalue(uv->v);
52 return uv;
53}
54
55
56UpVal *luaF_findupval (lua_State *L, StkId level) {
57 global_State *g = G(L);
58 GCObject **pp = &L->openupval;
59 UpVal *p;
60 UpVal *uv;
61 while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {
62 lua_assert(p->v != &p->u.value);
63 if (p->v == level) { /* found a corresponding upvalue? */
64 if (isdead(g, obj2gco(p))) /* is it dead? */
65 changewhite(obj2gco(p)); /* ressurect it */
66 return p;
67 }
68 pp = &p->next;
69 }
70 uv = luaM_new(L, UpVal); /* not found: create a new one */
71 uv->tt = LUA_TUPVAL;
72 uv->marked = luaC_white(g);
73 uv->v = level; /* current value lives in the stack */
74 uv->next = *pp; /* chain it in the proper position */
75 *pp = obj2gco(uv);
76 uv->u.l.prev = &g->uvhead; /* double link it in `uvhead' list */
77 uv->u.l.next = g->uvhead.u.l.next;
78 uv->u.l.next->u.l.prev = uv;
79 g->uvhead.u.l.next = uv;
80 lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
81 return uv;
82}
83
84
85static void unlinkupval (UpVal *uv) {
86 lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
87 uv->u.l.next->u.l.prev = uv->u.l.prev; /* remove from `uvhead' list */
88 uv->u.l.prev->u.l.next = uv->u.l.next;
89}
90
91
92void luaF_freeupval (lua_State *L, UpVal *uv) {
93 if (uv->v != &uv->u.value) /* is it open? */
94 unlinkupval(uv); /* remove from open list */
95 luaM_free(L, uv); /* free upvalue */
96}
97
98
99void luaF_close (lua_State *L, StkId level) {
100 UpVal *uv;
101 global_State *g = G(L);
102 while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {
103 GCObject *o = obj2gco(uv);
104 lua_assert(!isblack(o) && uv->v != &uv->u.value);
105 L->openupval = uv->next; /* remove from `open' list */
106 if (isdead(g, o))
107 luaF_freeupval(L, uv); /* free upvalue */
108 else {
109 unlinkupval(uv);
110 setobj(L, &uv->u.value, uv->v);
111 uv->v = &uv->u.value; /* now current value lives here */
112 luaC_linkupval(L, uv); /* link upvalue into `gcroot' list */
113 }
114 }
115}
116
117
118Proto *luaF_newproto (lua_State *L) {
119 Proto *f = luaM_new(L, Proto);
120 luaC_link(L, obj2gco(f), LUA_TPROTO);
121 f->k = NULL;
122 f->sizek = 0;
123 f->p = NULL;
124 f->sizep = 0;
125 f->code = NULL;
126 f->sizecode = 0;
127 f->sizelineinfo = 0;
128 f->sizeupvalues = 0;
129 f->nups = 0;
130 f->upvalues = NULL;
131 f->numparams = 0;
132 f->is_vararg = 0;
133 f->maxstacksize = 0;
134 f->lineinfo = NULL;
135 f->sizelocvars = 0;
136 f->locvars = NULL;
137 f->linedefined = 0;
138 f->lastlinedefined = 0;
139 f->source = NULL;
140 /* LuaJIT extensions */
141 f->jit_mcode = NULL;
142 f->jit_szmcode = 0;
143 f->jit_status = JIT_S_NONE;
144 return f;
145}
146
147
148void luaF_freeproto (lua_State *L, Proto *f) {
149 luaJIT_freeproto(L, f);
150 luaM_freearray(L, f->code, f->sizecode, Instruction);
151 luaM_freearray(L, f->p, f->sizep, Proto *);
152 luaM_freearray(L, f->k, f->sizek, TValue);
153 luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
154 luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
155 luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);
156 luaM_free(L, f);
157}
158
159
160void luaF_freeclosure (lua_State *L, Closure *c) {
161 int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :
162 sizeLclosure(c->l.nupvalues);
163 luaM_freemem(L, c, size);
164}
165
166
167/*
168** Look for n-th local variable at line `line' in function `func'.
169** Returns NULL if not found.
170*/
171const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
172 int i;
173 for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
174 if (pc < f->locvars[i].endpc) { /* is variable active? */
175 local_number--;
176 if (local_number == 0)
177 return getstr(f->locvars[i].varname);
178 }
179 }
180 return NULL; /* not found */
181}
182
diff --git a/libraries/LuaJIT-1.1.7/src/lfunc.h b/libraries/LuaJIT-1.1.7/src/lfunc.h
new file mode 100644
index 0000000..a68cf51
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lfunc.h
@@ -0,0 +1,34 @@
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
21LUAI_FUNC Proto *luaF_newproto (lua_State *L);
22LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e);
23LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e);
24LUAI_FUNC UpVal *luaF_newupval (lua_State *L);
25LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
26LUAI_FUNC void luaF_close (lua_State *L, StkId level);
27LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
28LUAI_FUNC void luaF_freeclosure (lua_State *L, Closure *c);
29LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);
30LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
31 int pc);
32
33
34#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lgc.c b/libraries/LuaJIT-1.1.7/src/lgc.c
new file mode 100644
index 0000000..d9e0b78
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lgc.c
@@ -0,0 +1,711 @@
1/*
2** $Id: lgc.c,v 2.38.1.1 2007/12/27 13:02:25 roberto Exp $
3** Garbage Collector
4** See Copyright Notice in lua.h
5*/
6
7#include <string.h>
8
9#define lgc_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 "lgc.h"
18#include "lmem.h"
19#include "lobject.h"
20#include "lstate.h"
21#include "lstring.h"
22#include "ltable.h"
23#include "ltm.h"
24
25
26#define GCSTEPSIZE 1024u
27#define GCSWEEPMAX 40
28#define GCSWEEPCOST 10
29#define GCFINALIZECOST 100
30
31
32#define maskmarks cast_byte(~(bitmask(BLACKBIT)|WHITEBITS))
33
34#define makewhite(g,x) \
35 ((x)->gch.marked = cast_byte(((x)->gch.marked & maskmarks) | luaC_white(g)))
36
37#define white2gray(x) reset2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
38#define black2gray(x) resetbit((x)->gch.marked, BLACKBIT)
39
40#define stringmark(s) reset2bits((s)->tsv.marked, WHITE0BIT, WHITE1BIT)
41
42
43#define isfinalized(u) testbit((u)->marked, FINALIZEDBIT)
44#define markfinalized(u) l_setbit((u)->marked, FINALIZEDBIT)
45
46
47#define KEYWEAK bitmask(KEYWEAKBIT)
48#define VALUEWEAK bitmask(VALUEWEAKBIT)
49
50
51
52#define markvalue(g,o) { checkconsistency(o); \
53 if (iscollectable(o) && iswhite(gcvalue(o))) reallymarkobject(g,gcvalue(o)); }
54
55#define markobject(g,t) { if (iswhite(obj2gco(t))) \
56 reallymarkobject(g, obj2gco(t)); }
57
58
59#define setthreshold(g) (g->GCthreshold = (g->estimate/100) * g->gcpause)
60
61
62static void removeentry (Node *n) {
63 lua_assert(ttisnil(gval(n)));
64 if (iscollectable(gkey(n)))
65 setttype(gkey(n), LUA_TDEADKEY); /* dead key; remove it */
66}
67
68
69static void reallymarkobject (global_State *g, GCObject *o) {
70 lua_assert(iswhite(o) && !isdead(g, o));
71 white2gray(o);
72 switch (o->gch.tt) {
73 case LUA_TSTRING: {
74 return;
75 }
76 case LUA_TUSERDATA: {
77 Table *mt = gco2u(o)->metatable;
78 gray2black(o); /* udata are never gray */
79 if (mt) markobject(g, mt);
80 markobject(g, gco2u(o)->env);
81 return;
82 }
83 case LUA_TUPVAL: {
84 UpVal *uv = gco2uv(o);
85 markvalue(g, uv->v);
86 if (uv->v == &uv->u.value) /* closed? */
87 gray2black(o); /* open upvalues are never black */
88 return;
89 }
90 case LUA_TFUNCTION: {
91 gco2cl(o)->c.gclist = g->gray;
92 g->gray = o;
93 break;
94 }
95 case LUA_TTABLE: {
96 gco2h(o)->gclist = g->gray;
97 g->gray = o;
98 break;
99 }
100 case LUA_TTHREAD: {
101 gco2th(o)->gclist = g->gray;
102 g->gray = o;
103 break;
104 }
105 case LUA_TPROTO: {
106 gco2p(o)->gclist = g->gray;
107 g->gray = o;
108 break;
109 }
110 default: lua_assert(0);
111 }
112}
113
114
115static void marktmu (global_State *g) {
116 GCObject *u = g->tmudata;
117 if (u) {
118 do {
119 u = u->gch.next;
120 makewhite(g, u); /* may be marked, if left from previous GC */
121 reallymarkobject(g, u);
122 } while (u != g->tmudata);
123 }
124}
125
126
127/* move `dead' udata that need finalization to list `tmudata' */
128size_t luaC_separateudata (lua_State *L, int all) {
129 global_State *g = G(L);
130 size_t deadmem = 0;
131 GCObject **p = &g->mainthread->next;
132 GCObject *curr;
133 while ((curr = *p) != NULL) {
134 if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))
135 p = &curr->gch.next; /* don't bother with them */
136 else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {
137 markfinalized(gco2u(curr)); /* don't need finalization */
138 p = &curr->gch.next;
139 }
140 else { /* must call its gc method */
141 deadmem += sizeudata(gco2u(curr));
142 markfinalized(gco2u(curr));
143 *p = curr->gch.next;
144 /* link `curr' at the end of `tmudata' list */
145 if (g->tmudata == NULL) /* list is empty? */
146 g->tmudata = curr->gch.next = curr; /* creates a circular list */
147 else {
148 curr->gch.next = g->tmudata->gch.next;
149 g->tmudata->gch.next = curr;
150 g->tmudata = curr;
151 }
152 }
153 }
154 return deadmem;
155}
156
157
158static int traversetable (global_State *g, Table *h) {
159 int i;
160 int weakkey = 0;
161 int weakvalue = 0;
162 const TValue *mode;
163 if (h->metatable)
164 markobject(g, h->metatable);
165 mode = gfasttm(g, h->metatable, TM_MODE);
166 if (mode && ttisstring(mode)) { /* is there a weak mode? */
167 weakkey = (strchr(svalue(mode), 'k') != NULL);
168 weakvalue = (strchr(svalue(mode), 'v') != NULL);
169 if (weakkey || weakvalue) { /* is really weak? */
170 h->marked &= ~(KEYWEAK | VALUEWEAK); /* clear bits */
171 h->marked |= cast_byte((weakkey << KEYWEAKBIT) |
172 (weakvalue << VALUEWEAKBIT));
173 h->gclist = g->weak; /* must be cleared after GC, ... */
174 g->weak = obj2gco(h); /* ... so put in the appropriate list */
175 }
176 }
177 if (weakkey && weakvalue) return 1;
178 if (!weakvalue) {
179 i = h->sizearray;
180 while (i--)
181 markvalue(g, &h->array[i]);
182 }
183 i = sizenode(h);
184 while (i--) {
185 Node *n = gnode(h, i);
186 lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));
187 if (ttisnil(gval(n)))
188 removeentry(n); /* remove empty entries */
189 else {
190 lua_assert(!ttisnil(gkey(n)));
191 if (!weakkey) markvalue(g, gkey(n));
192 if (!weakvalue) markvalue(g, gval(n));
193 }
194 }
195 return weakkey || weakvalue;
196}
197
198
199/*
200** All marks are conditional because a GC may happen while the
201** prototype is still being created
202*/
203static void traverseproto (global_State *g, Proto *f) {
204 int i;
205 if (f->source) stringmark(f->source);
206 for (i=0; i<f->sizek; i++) /* mark literals */
207 markvalue(g, &f->k[i]);
208 for (i=0; i<f->sizeupvalues; i++) { /* mark upvalue names */
209 if (f->upvalues[i])
210 stringmark(f->upvalues[i]);
211 }
212 for (i=0; i<f->sizep; i++) { /* mark nested protos */
213 if (f->p[i])
214 markobject(g, f->p[i]);
215 }
216 for (i=0; i<f->sizelocvars; i++) { /* mark local-variable names */
217 if (f->locvars[i].varname)
218 stringmark(f->locvars[i].varname);
219 }
220}
221
222
223
224static void traverseclosure (global_State *g, Closure *cl) {
225 markobject(g, cl->c.env);
226 if (cl->c.isC) {
227 int i;
228 for (i=0; i<cl->c.nupvalues; i++) /* mark its upvalues */
229 markvalue(g, &cl->c.upvalue[i]);
230 }
231 else {
232 int i;
233 lua_assert(cl->l.nupvalues == cl->l.p->nups);
234 markobject(g, cl->l.p);
235 for (i=0; i<cl->l.nupvalues; i++) /* mark its upvalues */
236 markobject(g, cl->l.upvals[i]);
237 }
238}
239
240
241static void checkstacksizes (lua_State *L, StkId max) {
242 int ci_used = cast_int(L->ci - L->base_ci); /* number of `ci' in use */
243 int s_used = cast_int(max - L->stack); /* part of stack in use */
244 if (L->size_ci > LUAI_MAXCALLS) /* handling overflow? */
245 return; /* do not touch the stacks */
246 if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)
247 luaD_reallocCI(L, L->size_ci/2); /* still big enough... */
248 condhardstacktests(luaD_reallocCI(L, ci_used + 1));
249 if (4*s_used < L->stacksize &&
250 2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize)
251 luaD_reallocstack(L, L->stacksize/2); /* still big enough... */
252 condhardstacktests(luaD_reallocstack(L, s_used));
253}
254
255
256static void traversestack (global_State *g, lua_State *l) {
257 StkId o, lim;
258 CallInfo *ci;
259 markvalue(g, gt(l));
260 lim = l->top;
261 for (ci = l->base_ci; ci <= l->ci; ci++) {
262 lua_assert(ci->top <= l->stack_last);
263 if (lim < ci->top) lim = ci->top;
264 }
265 for (o = l->stack; o < l->top; o++)
266 markvalue(g, o);
267 for (; o <= lim; o++)
268 setnilvalue(o);
269 checkstacksizes(l, lim);
270}
271
272
273/*
274** traverse one gray object, turning it to black.
275** Returns `quantity' traversed.
276*/
277static l_mem propagatemark (global_State *g) {
278 GCObject *o = g->gray;
279 lua_assert(isgray(o));
280 gray2black(o);
281 switch (o->gch.tt) {
282 case LUA_TTABLE: {
283 Table *h = gco2h(o);
284 g->gray = h->gclist;
285 if (traversetable(g, h)) /* table is weak? */
286 black2gray(o); /* keep it gray */
287 return sizeof(Table) + sizeof(TValue) * h->sizearray +
288 sizeof(Node) * sizenode(h);
289 }
290 case LUA_TFUNCTION: {
291 Closure *cl = gco2cl(o);
292 g->gray = cl->c.gclist;
293 traverseclosure(g, cl);
294 return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :
295 sizeLclosure(cl->l.nupvalues);
296 }
297 case LUA_TTHREAD: {
298 lua_State *th = gco2th(o);
299 g->gray = th->gclist;
300 th->gclist = g->grayagain;
301 g->grayagain = o;
302 black2gray(o);
303 traversestack(g, th);
304 return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
305 sizeof(CallInfo) * th->size_ci;
306 }
307 case LUA_TPROTO: {
308 Proto *p = gco2p(o);
309 g->gray = p->gclist;
310 traverseproto(g, p);
311 return sizeof(Proto) + sizeof(Instruction) * p->sizecode +
312 sizeof(Proto *) * p->sizep +
313 sizeof(TValue) * p->sizek +
314 sizeof(int) * p->sizelineinfo +
315 sizeof(LocVar) * p->sizelocvars +
316 sizeof(TString *) * p->sizeupvalues;
317 }
318 default: lua_assert(0); return 0;
319 }
320}
321
322
323static size_t propagateall (global_State *g) {
324 size_t m = 0;
325 while (g->gray) m += propagatemark(g);
326 return m;
327}
328
329
330/*
331** The next function tells whether a key or value can be cleared from
332** a weak table. Non-collectable objects are never removed from weak
333** tables. Strings behave as `values', so are never removed too. for
334** other objects: if really collected, cannot keep them; for userdata
335** being finalized, keep them in keys, but not in values
336*/
337static int iscleared (const TValue *o, int iskey) {
338 if (!iscollectable(o)) return 0;
339 if (ttisstring(o)) {
340 stringmark(rawtsvalue(o)); /* strings are `values', so are never weak */
341 return 0;
342 }
343 return iswhite(gcvalue(o)) ||
344 (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
345}
346
347
348/*
349** clear collected entries from weaktables
350*/
351static void cleartable (GCObject *l) {
352 while (l) {
353 Table *h = gco2h(l);
354 int i = h->sizearray;
355 lua_assert(testbit(h->marked, VALUEWEAKBIT) ||
356 testbit(h->marked, KEYWEAKBIT));
357 if (testbit(h->marked, VALUEWEAKBIT)) {
358 while (i--) {
359 TValue *o = &h->array[i];
360 if (iscleared(o, 0)) /* value was collected? */
361 setnilvalue(o); /* remove value */
362 }
363 }
364 i = sizenode(h);
365 while (i--) {
366 Node *n = gnode(h, i);
367 if (!ttisnil(gval(n)) && /* non-empty entry? */
368 (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {
369 setnilvalue(gval(n)); /* remove value ... */
370 removeentry(n); /* remove entry from table */
371 }
372 }
373 l = h->gclist;
374 }
375}
376
377
378static void freeobj (lua_State *L, GCObject *o) {
379 switch (o->gch.tt) {
380 case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
381 case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;
382 case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
383 case LUA_TTABLE: luaH_free(L, gco2h(o)); break;
384 case LUA_TTHREAD: {
385 lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);
386 luaE_freethread(L, gco2th(o));
387 break;
388 }
389 case LUA_TSTRING: {
390 G(L)->strt.nuse--;
391 luaM_freemem(L, o, sizestring(gco2ts(o)));
392 break;
393 }
394 case LUA_TUSERDATA: {
395 luaM_freemem(L, o, sizeudata(gco2u(o)));
396 break;
397 }
398 default: lua_assert(0);
399 }
400}
401
402
403
404#define sweepwholelist(L,p) sweeplist(L,p,MAX_LUMEM)
405
406
407static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
408 GCObject *curr;
409 global_State *g = G(L);
410 int deadmask = otherwhite(g);
411 while ((curr = *p) != NULL && count-- > 0) {
412 if (curr->gch.tt == LUA_TTHREAD) /* sweep open upvalues of each thread */
413 sweepwholelist(L, &gco2th(curr)->openupval);
414 if ((curr->gch.marked ^ WHITEBITS) & deadmask) { /* not dead? */
415 lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));
416 makewhite(g, curr); /* make it white (for next cycle) */
417 p = &curr->gch.next;
418 }
419 else { /* must erase `curr' */
420 lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));
421 *p = curr->gch.next;
422 if (curr == g->rootgc) /* is the first element of the list? */
423 g->rootgc = curr->gch.next; /* adjust first */
424 freeobj(L, curr);
425 }
426 }
427 return p;
428}
429
430
431static void checkSizes (lua_State *L) {
432 global_State *g = G(L);
433 /* check size of string hash */
434 if (g->strt.nuse < cast(lu_int32, g->strt.size/4) &&
435 g->strt.size > MINSTRTABSIZE*2)
436 luaS_resize(L, g->strt.size/2); /* table is too big */
437 /* check size of buffer */
438 if (luaZ_sizebuffer(&g->buff) > LUA_MINBUFFER*2) { /* buffer too big? */
439 size_t newsize = luaZ_sizebuffer(&g->buff) / 2;
440 luaZ_resizebuffer(L, &g->buff, newsize);
441 }
442}
443
444
445static void GCTM (lua_State *L) {
446 global_State *g = G(L);
447 GCObject *o = g->tmudata->gch.next; /* get first element */
448 Udata *udata = rawgco2u(o);
449 const TValue *tm;
450 /* remove udata from `tmudata' */
451 if (o == g->tmudata) /* last element? */
452 g->tmudata = NULL;
453 else
454 g->tmudata->gch.next = udata->uv.next;
455 udata->uv.next = g->mainthread->next; /* return it to `root' list */
456 g->mainthread->next = o;
457 makewhite(g, o);
458 tm = fasttm(L, udata->uv.metatable, TM_GC);
459 if (tm != NULL) {
460 lu_byte oldah = L->allowhook;
461 lu_mem oldt = g->GCthreshold;
462 L->allowhook = 0; /* stop debug hooks during GC tag method */
463 g->GCthreshold = 2*g->totalbytes; /* avoid GC steps */
464 setobj2s(L, L->top, tm);
465 setuvalue(L, L->top+1, udata);
466 L->top += 2;
467 luaD_call(L, L->top - 2, 0);
468 L->allowhook = oldah; /* restore hooks */
469 g->GCthreshold = oldt; /* restore threshold */
470 }
471}
472
473
474/*
475** Call all GC tag methods
476*/
477void luaC_callGCTM (lua_State *L) {
478 while (G(L)->tmudata)
479 GCTM(L);
480}
481
482
483void luaC_freeall (lua_State *L) {
484 global_State *g = G(L);
485 int i;
486 g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT); /* mask to collect all elements */
487 sweepwholelist(L, &g->rootgc);
488 for (i = 0; i < g->strt.size; i++) /* free all string lists */
489 sweepwholelist(L, &g->strt.hash[i]);
490}
491
492
493static void markmt (global_State *g) {
494 int i;
495 for (i=0; i<NUM_TAGS; i++)
496 if (g->mt[i]) markobject(g, g->mt[i]);
497}
498
499
500/* mark root set */
501static void markroot (lua_State *L) {
502 global_State *g = G(L);
503 g->gray = NULL;
504 g->grayagain = NULL;
505 g->weak = NULL;
506 markobject(g, g->mainthread);
507 /* make global table be traversed before main stack */
508 markvalue(g, gt(g->mainthread));
509 markvalue(g, registry(L));
510 markmt(g);
511 g->gcstate = GCSpropagate;
512}
513
514
515static void remarkupvals (global_State *g) {
516 UpVal *uv;
517 for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
518 lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
519 if (isgray(obj2gco(uv)))
520 markvalue(g, uv->v);
521 }
522}
523
524
525static void atomic (lua_State *L) {
526 global_State *g = G(L);
527 size_t udsize; /* total size of userdata to be finalized */
528 /* remark occasional upvalues of (maybe) dead threads */
529 remarkupvals(g);
530 /* traverse objects cautch by write barrier and by 'remarkupvals' */
531 propagateall(g);
532 /* remark weak tables */
533 g->gray = g->weak;
534 g->weak = NULL;
535 lua_assert(!iswhite(obj2gco(g->mainthread)));
536 markobject(g, L); /* mark running thread */
537 markmt(g); /* mark basic metatables (again) */
538 propagateall(g);
539 /* remark gray again */
540 g->gray = g->grayagain;
541 g->grayagain = NULL;
542 propagateall(g);
543 udsize = luaC_separateudata(L, 0); /* separate userdata to be finalized */
544 marktmu(g); /* mark `preserved' userdata */
545 udsize += propagateall(g); /* remark, to propagate `preserveness' */
546 cleartable(g->weak); /* remove collected objects from weak tables */
547 /* flip current white */
548 g->currentwhite = cast_byte(otherwhite(g));
549 g->sweepstrgc = 0;
550 g->sweepgc = &g->rootgc;
551 g->gcstate = GCSsweepstring;
552 g->estimate = g->totalbytes - udsize; /* first estimate */
553}
554
555
556static l_mem singlestep (lua_State *L) {
557 global_State *g = G(L);
558 /*lua_checkmemory(L);*/
559 switch (g->gcstate) {
560 case GCSpause: {
561 markroot(L); /* start a new collection */
562 return 0;
563 }
564 case GCSpropagate: {
565 if (g->gray)
566 return propagatemark(g);
567 else { /* no more `gray' objects */
568 atomic(L); /* finish mark phase */
569 return 0;
570 }
571 }
572 case GCSsweepstring: {
573 lu_mem old = g->totalbytes;
574 sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);
575 if (g->sweepstrgc >= g->strt.size) /* nothing more to sweep? */
576 g->gcstate = GCSsweep; /* end sweep-string phase */
577 lua_assert(old >= g->totalbytes);
578 g->estimate -= old - g->totalbytes;
579 return GCSWEEPCOST;
580 }
581 case GCSsweep: {
582 lu_mem old = g->totalbytes;
583 g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
584 if (*g->sweepgc == NULL) { /* nothing more to sweep? */
585 checkSizes(L);
586 g->gcstate = GCSfinalize; /* end sweep phase */
587 }
588 lua_assert(old >= g->totalbytes);
589 g->estimate -= old - g->totalbytes;
590 return GCSWEEPMAX*GCSWEEPCOST;
591 }
592 case GCSfinalize: {
593 if (g->tmudata) {
594 GCTM(L);
595 if (g->estimate > GCFINALIZECOST)
596 g->estimate -= GCFINALIZECOST;
597 return GCFINALIZECOST;
598 }
599 else {
600 g->gcstate = GCSpause; /* end collection */
601 g->gcdept = 0;
602 return 0;
603 }
604 }
605 default: lua_assert(0); return 0;
606 }
607}
608
609
610void luaC_step (lua_State *L) {
611 global_State *g = G(L);
612 l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;
613 if (lim == 0)
614 lim = (MAX_LUMEM-1)/2; /* no limit */
615 g->gcdept += g->totalbytes - g->GCthreshold;
616 do {
617 lim -= singlestep(L);
618 if (g->gcstate == GCSpause)
619 break;
620 } while (lim > 0);
621 if (g->gcstate != GCSpause) {
622 if (g->gcdept < GCSTEPSIZE)
623 g->GCthreshold = g->totalbytes + GCSTEPSIZE; /* - lim/g->gcstepmul;*/
624 else {
625 g->gcdept -= GCSTEPSIZE;
626 g->GCthreshold = g->totalbytes;
627 }
628 }
629 else {
630 lua_assert(g->totalbytes >= g->estimate);
631 setthreshold(g);
632 }
633}
634
635
636void luaC_fullgc (lua_State *L) {
637 global_State *g = G(L);
638 if (g->gcstate <= GCSpropagate) {
639 /* reset sweep marks to sweep all elements (returning them to white) */
640 g->sweepstrgc = 0;
641 g->sweepgc = &g->rootgc;
642 /* reset other collector lists */
643 g->gray = NULL;
644 g->grayagain = NULL;
645 g->weak = NULL;
646 g->gcstate = GCSsweepstring;
647 }
648 lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
649 /* finish any pending sweep phase */
650 while (g->gcstate != GCSfinalize) {
651 lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);
652 singlestep(L);
653 }
654 markroot(L);
655 while (g->gcstate != GCSpause) {
656 singlestep(L);
657 }
658 setthreshold(g);
659}
660
661
662void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
663 global_State *g = G(L);
664 lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
665 lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
666 lua_assert(ttype(&o->gch) != LUA_TTABLE);
667 /* must keep invariant? */
668 if (g->gcstate == GCSpropagate)
669 reallymarkobject(g, v); /* restore invariant */
670 else /* don't mind */
671 makewhite(g, o); /* mark as white just to avoid other barriers */
672}
673
674
675void luaC_barrierback (lua_State *L, Table *t) {
676 global_State *g = G(L);
677 GCObject *o = obj2gco(t);
678 lua_assert(isblack(o) && !isdead(g, o));
679 lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
680 black2gray(o); /* make table gray (again) */
681 t->gclist = g->grayagain;
682 g->grayagain = o;
683}
684
685
686void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {
687 global_State *g = G(L);
688 o->gch.next = g->rootgc;
689 g->rootgc = o;
690 o->gch.marked = luaC_white(g);
691 o->gch.tt = tt;
692}
693
694
695void luaC_linkupval (lua_State *L, UpVal *uv) {
696 global_State *g = G(L);
697 GCObject *o = obj2gco(uv);
698 o->gch.next = g->rootgc; /* link upvalue into `rootgc' list */
699 g->rootgc = o;
700 if (isgray(o)) {
701 if (g->gcstate == GCSpropagate) {
702 gray2black(o); /* closed upvalues need barrier */
703 luaC_barrier(L, uv, uv->v);
704 }
705 else { /* sweep phase: sweep it (turning it into white) */
706 makewhite(g, o);
707 lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
708 }
709 }
710}
711
diff --git a/libraries/LuaJIT-1.1.7/src/lgc.h b/libraries/LuaJIT-1.1.7/src/lgc.h
new file mode 100644
index 0000000..5a8dc60
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lgc.h
@@ -0,0 +1,110 @@
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
99LUAI_FUNC size_t luaC_separateudata (lua_State *L, int all);
100LUAI_FUNC void luaC_callGCTM (lua_State *L);
101LUAI_FUNC void luaC_freeall (lua_State *L);
102LUAI_FUNC void luaC_step (lua_State *L);
103LUAI_FUNC void luaC_fullgc (lua_State *L);
104LUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt);
105LUAI_FUNC void luaC_linkupval (lua_State *L, UpVal *uv);
106LUAI_FUNC void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v);
107LUAI_FUNC void luaC_barrierback (lua_State *L, Table *t);
108
109
110#endif
diff --git a/libraries/LuaJIT-1.1.7/src/linit.c b/libraries/LuaJIT-1.1.7/src/linit.c
new file mode 100644
index 0000000..db24ccd
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/linit.c
@@ -0,0 +1,39 @@
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
17static 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 {LUA_JITLIBNAME, luaopen_jit},
27 {NULL, NULL}
28};
29
30
31LUALIB_API void luaL_openlibs (lua_State *L) {
32 const luaL_Reg *lib = lualibs;
33 for (; lib->func; lib++) {
34 lua_pushcfunction(L, lib->func);
35 lua_pushstring(L, lib->name);
36 lua_call(L, 1, 0);
37 }
38}
39
diff --git a/libraries/LuaJIT-1.1.7/src/liolib.c b/libraries/LuaJIT-1.1.7/src/liolib.c
new file mode 100644
index 0000000..8de2547
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/liolib.c
@@ -0,0 +1,556 @@
1/*
2** $Id: liolib.c,v 2.73.1.3 2008/01/18 17:47:43 roberto Exp $
3** Standard I/O (and system) library
4** See Copyright Notice in lua.h
5*/
6
7
8#include <errno.h>
9#include <stdio.h>
10#include <stdlib.h>
11#include <string.h>
12
13#define liolib_c
14#define LUA_LIB
15
16#include "lua.h"
17
18#include "lauxlib.h"
19#include "lualib.h"
20
21
22
23#define IO_INPUT 1
24#define IO_OUTPUT 2
25
26
27static const char *const fnames[] = {"input", "output"};
28
29
30static int pushresult (lua_State *L, int i, const char *filename) {
31 int en = errno; /* calls to Lua API may change this value */
32 if (i) {
33 lua_pushboolean(L, 1);
34 return 1;
35 }
36 else {
37 lua_pushnil(L);
38 if (filename)
39 lua_pushfstring(L, "%s: %s", filename, strerror(en));
40 else
41 lua_pushfstring(L, "%s", strerror(en));
42 lua_pushinteger(L, en);
43 return 3;
44 }
45}
46
47
48static void fileerror (lua_State *L, int arg, const char *filename) {
49 lua_pushfstring(L, "%s: %s", filename, strerror(errno));
50 luaL_argerror(L, arg, lua_tostring(L, -1));
51}
52
53
54#define tofilep(L) ((FILE **)luaL_checkudata(L, 1, LUA_FILEHANDLE))
55
56
57static int io_type (lua_State *L) {
58 void *ud;
59 luaL_checkany(L, 1);
60 ud = lua_touserdata(L, 1);
61 lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
62 if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))
63 lua_pushnil(L); /* not a file */
64 else if (*((FILE **)ud) == NULL)
65 lua_pushliteral(L, "closed file");
66 else
67 lua_pushliteral(L, "file");
68 return 1;
69}
70
71
72static FILE *tofile (lua_State *L) {
73 FILE **f = tofilep(L);
74 if (*f == NULL)
75 luaL_error(L, "attempt to use a closed file");
76 return *f;
77}
78
79
80
81/*
82** When creating file handles, always creates a `closed' file handle
83** before opening the actual file; so, if there is a memory error, the
84** file is not left opened.
85*/
86static FILE **newfile (lua_State *L) {
87 FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
88 *pf = NULL; /* file handle is currently `closed' */
89 luaL_getmetatable(L, LUA_FILEHANDLE);
90 lua_setmetatable(L, -2);
91 return pf;
92}
93
94
95/*
96** function to (not) close the standard files stdin, stdout, and stderr
97*/
98static int io_noclose (lua_State *L) {
99 lua_pushnil(L);
100 lua_pushliteral(L, "cannot close standard file");
101 return 2;
102}
103
104
105/*
106** function to close 'popen' files
107*/
108static int io_pclose (lua_State *L) {
109 FILE **p = tofilep(L);
110 int ok = lua_pclose(L, *p);
111 *p = NULL;
112 return pushresult(L, ok, NULL);
113}
114
115
116/*
117** function to close regular files
118*/
119static int io_fclose (lua_State *L) {
120 FILE **p = tofilep(L);
121 int ok = (fclose(*p) == 0);
122 *p = NULL;
123 return pushresult(L, ok, NULL);
124}
125
126
127static int aux_close (lua_State *L) {
128 lua_getfenv(L, 1);
129 lua_getfield(L, -1, "__close");
130 return (lua_tocfunction(L, -1))(L);
131}
132
133
134static int io_close (lua_State *L) {
135 if (lua_isnone(L, 1))
136 lua_rawgeti(L, LUA_ENVIRONINDEX, IO_OUTPUT);
137 tofile(L); /* make sure argument is a file */
138 return aux_close(L);
139}
140
141
142static int io_gc (lua_State *L) {
143 FILE *f = *tofilep(L);
144 /* ignore closed files */
145 if (f != NULL)
146 aux_close(L);
147 return 0;
148}
149
150
151static int io_tostring (lua_State *L) {
152 FILE *f = *tofilep(L);
153 if (f == NULL)
154 lua_pushliteral(L, "file (closed)");
155 else
156 lua_pushfstring(L, "file (%p)", f);
157 return 1;
158}
159
160
161static int io_open (lua_State *L) {
162 const char *filename = luaL_checkstring(L, 1);
163 const char *mode = luaL_optstring(L, 2, "r");
164 FILE **pf = newfile(L);
165 *pf = fopen(filename, mode);
166 return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
167}
168
169
170/*
171** this function has a separated environment, which defines the
172** correct __close for 'popen' files
173*/
174static int io_popen (lua_State *L) {
175 const char *filename = luaL_checkstring(L, 1);
176 const char *mode = luaL_optstring(L, 2, "r");
177 FILE **pf = newfile(L);
178 *pf = lua_popen(L, filename, mode);
179 return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
180}
181
182
183static int io_tmpfile (lua_State *L) {
184 FILE **pf = newfile(L);
185 *pf = tmpfile();
186 return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;
187}
188
189
190static FILE *getiofile (lua_State *L, int findex) {
191 FILE *f;
192 lua_rawgeti(L, LUA_ENVIRONINDEX, findex);
193 f = *(FILE **)lua_touserdata(L, -1);
194 if (f == NULL)
195 luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
196 return f;
197}
198
199
200static int g_iofile (lua_State *L, int f, const char *mode) {
201 if (!lua_isnoneornil(L, 1)) {
202 const char *filename = lua_tostring(L, 1);
203 if (filename) {
204 FILE **pf = newfile(L);
205 *pf = fopen(filename, mode);
206 if (*pf == NULL)
207 fileerror(L, 1, filename);
208 }
209 else {
210 tofile(L); /* check that it's a valid file handle */
211 lua_pushvalue(L, 1);
212 }
213 lua_rawseti(L, LUA_ENVIRONINDEX, f);
214 }
215 /* return current value */
216 lua_rawgeti(L, LUA_ENVIRONINDEX, f);
217 return 1;
218}
219
220
221static int io_input (lua_State *L) {
222 return g_iofile(L, IO_INPUT, "r");
223}
224
225
226static int io_output (lua_State *L) {
227 return g_iofile(L, IO_OUTPUT, "w");
228}
229
230
231static int io_readline (lua_State *L);
232
233
234static void aux_lines (lua_State *L, int idx, int toclose) {
235 lua_pushvalue(L, idx);
236 lua_pushboolean(L, toclose); /* close/not close file when finished */
237 lua_pushcclosure(L, io_readline, 2);
238}
239
240
241static int f_lines (lua_State *L) {
242 tofile(L); /* check that it's a valid file handle */
243 aux_lines(L, 1, 0);
244 return 1;
245}
246
247
248static int io_lines (lua_State *L) {
249 if (lua_isnoneornil(L, 1)) { /* no arguments? */
250 /* will iterate over default input */
251 lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);
252 return f_lines(L);
253 }
254 else {
255 const char *filename = luaL_checkstring(L, 1);
256 FILE **pf = newfile(L);
257 *pf = fopen(filename, "r");
258 if (*pf == NULL)
259 fileerror(L, 1, filename);
260 aux_lines(L, lua_gettop(L), 1);
261 return 1;
262 }
263}
264
265
266/*
267** {======================================================
268** READ
269** =======================================================
270*/
271
272
273static int read_number (lua_State *L, FILE *f) {
274 lua_Number d;
275 if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
276 lua_pushnumber(L, d);
277 return 1;
278 }
279 else {
280 lua_pushnil(L); /* "result" to be removed */
281 return 0; /* read fails */
282 }
283}
284
285
286static int test_eof (lua_State *L, FILE *f) {
287 int c = getc(f);
288 ungetc(c, f);
289 lua_pushlstring(L, NULL, 0);
290 return (c != EOF);
291}
292
293
294static int read_line (lua_State *L, FILE *f) {
295 luaL_Buffer b;
296 luaL_buffinit(L, &b);
297 for (;;) {
298 size_t l;
299 char *p = luaL_prepbuffer(&b);
300 if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) { /* eof? */
301 luaL_pushresult(&b); /* close buffer */
302 return (lua_objlen(L, -1) > 0); /* check whether read something */
303 }
304 l = strlen(p);
305 if (l == 0 || p[l-1] != '\n')
306 luaL_addsize(&b, l);
307 else {
308 luaL_addsize(&b, l - 1); /* do not include `eol' */
309 luaL_pushresult(&b); /* close buffer */
310 return 1; /* read at least an `eol' */
311 }
312 }
313}
314
315
316static int read_chars (lua_State *L, FILE *f, size_t n) {
317 size_t rlen; /* how much to read */
318 size_t nr; /* number of chars actually read */
319 luaL_Buffer b;
320 luaL_buffinit(L, &b);
321 rlen = LUAL_BUFFERSIZE; /* try to read that much each time */
322 do {
323 char *p = luaL_prepbuffer(&b);
324 if (rlen > n) rlen = n; /* cannot read more than asked */
325 nr = fread(p, sizeof(char), rlen, f);
326 luaL_addsize(&b, nr);
327 n -= nr; /* still have to read `n' chars */
328 } while (n > 0 && nr == rlen); /* until end of count or eof */
329 luaL_pushresult(&b); /* close buffer */
330 return (n == 0 || lua_objlen(L, -1) > 0);
331}
332
333
334static int g_read (lua_State *L, FILE *f, int first) {
335 int nargs = lua_gettop(L) - 1;
336 int success;
337 int n;
338 clearerr(f);
339 if (nargs == 0) { /* no arguments? */
340 success = read_line(L, f);
341 n = first+1; /* to return 1 result */
342 }
343 else { /* ensure stack space for all results and for auxlib's buffer */
344 luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
345 success = 1;
346 for (n = first; nargs-- && success; n++) {
347 if (lua_type(L, n) == LUA_TNUMBER) {
348 size_t l = (size_t)lua_tointeger(L, n);
349 success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
350 }
351 else {
352 const char *p = lua_tostring(L, n);
353 luaL_argcheck(L, p && p[0] == '*', n, "invalid option");
354 switch (p[1]) {
355 case 'n': /* number */
356 success = read_number(L, f);
357 break;
358 case 'l': /* line */
359 success = read_line(L, f);
360 break;
361 case 'a': /* file */
362 read_chars(L, f, ~((size_t)0)); /* read MAX_SIZE_T chars */
363 success = 1; /* always success */
364 break;
365 default:
366 return luaL_argerror(L, n, "invalid format");
367 }
368 }
369 }
370 }
371 if (ferror(f))
372 return pushresult(L, 0, NULL);
373 if (!success) {
374 lua_pop(L, 1); /* remove last result */
375 lua_pushnil(L); /* push nil instead */
376 }
377 return n - first;
378}
379
380
381static int io_read (lua_State *L) {
382 return g_read(L, getiofile(L, IO_INPUT), 1);
383}
384
385
386static int f_read (lua_State *L) {
387 return g_read(L, tofile(L), 2);
388}
389
390
391static int io_readline (lua_State *L) {
392 FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
393 int sucess;
394 if (f == NULL) /* file is already closed? */
395 luaL_error(L, "file is already closed");
396 sucess = read_line(L, f);
397 if (ferror(f))
398 return luaL_error(L, "%s", strerror(errno));
399 if (sucess) return 1;
400 else { /* EOF */
401 if (lua_toboolean(L, lua_upvalueindex(2))) { /* generator created file? */
402 lua_settop(L, 0);
403 lua_pushvalue(L, lua_upvalueindex(1));
404 aux_close(L); /* close it */
405 }
406 return 0;
407 }
408}
409
410/* }====================================================== */
411
412
413static int g_write (lua_State *L, FILE *f, int arg) {
414 int nargs = lua_gettop(L) - 1;
415 int status = 1;
416 for (; nargs--; arg++) {
417 if (lua_type(L, arg) == LUA_TNUMBER) {
418 /* optimization: could be done exactly as for strings */
419 status = status &&
420 fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
421 }
422 else {
423 size_t l;
424 const char *s = luaL_checklstring(L, arg, &l);
425 status = status && (fwrite(s, sizeof(char), l, f) == l);
426 }
427 }
428 return pushresult(L, status, NULL);
429}
430
431
432static int io_write (lua_State *L) {
433 return g_write(L, getiofile(L, IO_OUTPUT), 1);
434}
435
436
437static int f_write (lua_State *L) {
438 return g_write(L, tofile(L), 2);
439}
440
441
442static int f_seek (lua_State *L) {
443 static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
444 static const char *const modenames[] = {"set", "cur", "end", NULL};
445 FILE *f = tofile(L);
446 int op = luaL_checkoption(L, 2, "cur", modenames);
447 long offset = luaL_optlong(L, 3, 0);
448 op = fseek(f, offset, mode[op]);
449 if (op)
450 return pushresult(L, 0, NULL); /* error */
451 else {
452 lua_pushinteger(L, ftell(f));
453 return 1;
454 }
455}
456
457
458static int f_setvbuf (lua_State *L) {
459 static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
460 static const char *const modenames[] = {"no", "full", "line", NULL};
461 FILE *f = tofile(L);
462 int op = luaL_checkoption(L, 2, NULL, modenames);
463 lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
464 int res = setvbuf(f, NULL, mode[op], sz);
465 return pushresult(L, res == 0, NULL);
466}
467
468
469
470static int io_flush (lua_State *L) {
471 return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
472}
473
474
475static int f_flush (lua_State *L) {
476 return pushresult(L, fflush(tofile(L)) == 0, NULL);
477}
478
479
480static const luaL_Reg iolib[] = {
481 {"close", io_close},
482 {"flush", io_flush},
483 {"input", io_input},
484 {"lines", io_lines},
485 {"open", io_open},
486 {"output", io_output},
487 {"popen", io_popen},
488 {"read", io_read},
489 {"tmpfile", io_tmpfile},
490 {"type", io_type},
491 {"write", io_write},
492 {NULL, NULL}
493};
494
495
496static const luaL_Reg flib[] = {
497 {"close", io_close},
498 {"flush", f_flush},
499 {"lines", f_lines},
500 {"read", f_read},
501 {"seek", f_seek},
502 {"setvbuf", f_setvbuf},
503 {"write", f_write},
504 {"__gc", io_gc},
505 {"__tostring", io_tostring},
506 {NULL, NULL}
507};
508
509
510static void createmeta (lua_State *L) {
511 luaL_newmetatable(L, LUA_FILEHANDLE); /* create metatable for file handles */
512 lua_pushvalue(L, -1); /* push metatable */
513 lua_setfield(L, -2, "__index"); /* metatable.__index = metatable */
514 luaL_register(L, NULL, flib); /* file methods */
515}
516
517
518static void createstdfile (lua_State *L, FILE *f, int k, const char *fname) {
519 *newfile(L) = f;
520 if (k > 0) {
521 lua_pushvalue(L, -1);
522 lua_rawseti(L, LUA_ENVIRONINDEX, k);
523 }
524 lua_pushvalue(L, -2); /* copy environment */
525 lua_setfenv(L, -2); /* set it */
526 lua_setfield(L, -3, fname);
527}
528
529
530static void newfenv (lua_State *L, lua_CFunction cls) {
531 lua_createtable(L, 0, 1);
532 lua_pushcfunction(L, cls);
533 lua_setfield(L, -2, "__close");
534}
535
536
537LUALIB_API int luaopen_io (lua_State *L) {
538 createmeta(L);
539 /* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */
540 newfenv(L, io_fclose);
541 lua_replace(L, LUA_ENVIRONINDEX);
542 /* open library */
543 luaL_register(L, LUA_IOLIBNAME, iolib);
544 /* create (and set) default files */
545 newfenv(L, io_noclose); /* close function for default files */
546 createstdfile(L, stdin, IO_INPUT, "stdin");
547 createstdfile(L, stdout, IO_OUTPUT, "stdout");
548 createstdfile(L, stderr, 0, "stderr");
549 lua_pop(L, 1); /* pop environment for default files */
550 lua_getfield(L, -1, "popen");
551 newfenv(L, io_pclose); /* create environment for 'popen' */
552 lua_setfenv(L, -2); /* set fenv for 'popen' */
553 lua_pop(L, 1); /* pop 'popen' */
554 return 1;
555}
556
diff --git a/libraries/LuaJIT-1.1.7/src/ljit.h b/libraries/LuaJIT-1.1.7/src/ljit.h
new file mode 100644
index 0000000..347de3b
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit.h
@@ -0,0 +1,167 @@
1/*
2** Interface to JIT engine.
3** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
4*/
5
6#ifndef ljit_h
7#define ljit_h
8
9#include "lobject.h"
10
11
12/* Define this to enable assertions when debugging LuaJIT. */
13#ifdef LUAJIT_ASSERT
14#include <assert.h>
15#define jit_assert(x) assert(x)
16#define DASM_CHECKS
17#else
18/* A better idea is to define lua_assert() in luaconf.h. */
19#define jit_assert(x) lua_assert(x)
20#endif
21
22/* Define this to set the C stack size for the compiler thread. */
23/* The compiler runs on the callers C stack otherwise. */
24#undef LUAJIT_COMPILER_CSTACK
25
26/* Hardcoded limits for the backend to avoid useless work. */
27/* Note: mind you, these are very generous limits. Check jit.opt, too. */
28#define LUAJIT_LIM_BYTECODE 3000 /* Max. # of bytecodes. */
29#define LUAJIT_LIM_MCODE 128000 /* Max. mcode size of a function. */
30
31/* Global JIT engine flags. */
32#define JIT_F_ON 0x0001 /* JIT engine is on. */
33#define JIT_F_COMPILING 0x0002 /* Currently compiling. */
34#define JIT_F_INIT_FAILED 0x0004 /* Initialization failed. */
35
36#define JIT_F_CPU_CMOV 0x0010 /* CPU has conditional move support. */
37#define JIT_F_CPU_SSE2 0x0020 /* CPU has SSE2 support. */
38
39#define JIT_F_DEBUG_CALL 0x0100 /* Compile with call hooks. */
40#define JIT_F_DEBUG_INS 0x0200 /* Compile with instruction hooks. */
41#define JIT_F_DEBUG 0x0f00 /* Union of all debug flags. */
42
43/* Temporary backend flags. */
44#define JIT_TF_USED_DEOPT 0x0001 /* Used .deopt segment. */
45
46/* JIT engine status codes for prototypes (grep "ORDER JIT_S"). */
47enum {
48 JIT_S_OK, /* OK, code has been compiled. */
49 JIT_S_NONE, /* Nothing compiled yet (default). */
50
51 JIT_S_OFF, /* Compilation for this prototype disabled. */
52 JIT_S_ENGINE_OFF, /* JIT engine is turned off. */
53 JIT_S_DELAYED, /* Compilation delayed (recursive invocation). */
54
55 JIT_S_TOOLARGE, /* Bytecode or machine code is too large. */
56 JIT_S_COMPILER_ERROR, /* Error from compiler frontend. */
57 JIT_S_DASM_ERROR, /* Error from DynASM engine. */
58
59 JIT_S_MAX
60};
61
62/* Machine code trailer and mcode fragment map. */
63typedef struct jit_MCTrailer {
64 char *mcode; /* Pointer to next machine code block. */
65 size_t sz; /* Size of next machine code block. */
66} jit_MCTrailer;
67
68typedef unsigned short jit_Mfm;
69
70/* Deliberately return a void * because the trailer is not fully aligned. */
71#define JIT_MCTRAILER(mcode, sz) \
72 ((void *)(((char *)(mcode))+(sz)-sizeof(jit_MCTrailer)))
73#define JIT_MCMFM(mcode, sz) \
74 ((jit_Mfm *)(((char *)(mcode))+(sz)-sizeof(jit_MCTrailer)-sizeof(jit_Mfm)))
75
76#define JIT_MFM_MAX 0x7ff0 /* Max. mcode fragment length. */
77#define JIT_MFM_MASK 0x7fff /* Tag mask. */
78#define JIT_MFM_MARK 0x8000 /* Deoptimized (main mfm), seek (deopt mfm). */
79#define JIT_MFM_COMBINE 0xfffd /* Combined with prev. instruction(s). */
80#define JIT_MFM_DEAD 0xfffe /* Dead instruction. */
81#define JIT_MFM_STOP 0xffff /* End of map. */
82
83#define jit_mfm_ismain(mfm) (!(*(mfm) & JIT_MFM_MARK))
84#define jit_mfm_isdeoptpc(mfm, pc) ((mfm)[-(pc)] & JIT_MFM_MARK)
85
86/* Deoptimization hints at end of mfm. */
87#define JIT_MFM_DEOPT_PAIRS 0xfffc /* CALL+TFORLOOP inlined (i)pairs. */
88
89/* Preallocation for the hash part of the compiler state table. */
90#define COMSTATE_PREALLOC 128
91
92/* Forward declaration for DynASM state. */
93struct dasm_State;
94
95/* Frontend wrapper. */
96typedef int (*jit_FrontWrap)(lua_State *L, Table *st);
97
98/* Global JIT state. */
99typedef struct jit_State {
100 /* Permanent backend environment: */
101 struct dasm_State *D; /* DynASM state. Keep this as the first field. */
102 void *mcodeheap; /* Private heap to allocate executable memory from. */
103 void **jsub; /* Addresses of JIT subroutines. */
104 void *jsubmcode; /* Base address of JSUB mcode. */
105 size_t szjsubmcode; /* Size of JSUB mcode. */
106 int numjsub; /* Number of JSUBs. */
107
108 /* Temporary backend environment (valid only while running): */
109 lua_State *L; /* Compiler thread. */
110 Table *comstate; /* Compiler state table. */
111 Proto *pt; /* Currently compiled prototype. */
112 const Instruction *nextins; /* Pointer to next instruction. */
113 jit_Mfm *mfm; /* Position in temporary mcode fragment map. */
114 int nextpc; /* Next PC. */
115 int combine; /* Number of following instructions to combine. */
116 unsigned int tflags; /* Temporary flags. */
117 int dasmstatus; /* DynASM status code. */
118
119 /* JIT engine fields: */
120 jit_FrontWrap frontwrap; /* Compiler frontend wrapper. */
121 unsigned int flags; /* Global JIT engine flags. */
122} jit_State;
123
124
125/* --- ljit_core.c */
126
127/* Initialize and free JIT engine state. */
128LUAI_FUNC void luaJIT_initstate(lua_State *L);
129LUAI_FUNC void luaJIT_freestate(lua_State *L);
130
131/* Compile and run a function. */
132LUAI_FUNC int luaJIT_run(lua_State *L, StkId func, int nresults);
133/* Deoptimize the current instruction. Return new mcode addr to continue. */
134LUAI_FUNC void *luaJIT_deoptimize(lua_State *L);
135
136/* Find relative PC (0 based) for a bytecode pointer or a JIT mcode address. */
137LUAI_FUNC int luaJIT_findpc(Proto *pt, const Instruction *savedpc);
138/* Find mcode address for PC (1 based). */
139LUAI_FUNC void *luaJIT_findmcode(Proto *pt, int pc);
140
141
142/* --- ljit_backend.c */
143
144/* Arch string. */
145LUAI_DATA const char luaJIT_arch[];
146/* Initialize and free compiler backend. */
147LUAI_FUNC int luaJIT_initbackend(lua_State *L);
148LUAI_FUNC void luaJIT_freebackend(lua_State *L);
149/* Compiler backend. */
150LUAI_FUNC int luaJIT_backend(lua_State *L);
151/* Notify backend that the debug mode may have changed. */
152LUAI_FUNC void luaJIT_debugnotify(jit_State *J);
153
154
155/* ---- ljit_mem.c */
156
157/* Free the mcode heap. */
158LUAI_FUNC void luaJIT_freemcodeheap(jit_State *J);
159/* Free mcode. */
160LUAI_FUNC void luaJIT_freemcode(jit_State *J, void *mcode, size_t sz);
161/* Free JIT structures in function prototype. */
162LUAI_FUNC void luaJIT_freeproto(lua_State *L, Proto *pt);
163/* Link generated code. */
164LUAI_FUNC int luaJIT_link(jit_State *J, void **mcodep, size_t *szp);
165
166
167#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_backend.c b/libraries/LuaJIT-1.1.7/src/ljit_backend.c
new file mode 100644
index 0000000..698342f
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_backend.c
@@ -0,0 +1,342 @@
1/*
2** LuaJIT wrapper for architecture-specific compiler backend.
3** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
4*/
5
6#include <math.h>
7#include <string.h>
8
9#define ljit_backend_c
10#define LUA_CORE
11
12#include "lua.h"
13
14#include "lobject.h"
15#include "lstate.h"
16#include "ldo.h"
17#include "lfunc.h"
18#include "lgc.h"
19#include "lstring.h"
20#include "ltable.h"
21#include "ltm.h"
22#include "lvm.h"
23#include "lopcodes.h"
24#include "ldebug.h"
25#include "lzio.h"
26
27#include "ljit.h"
28#include "ljit_hints.h"
29#include "ljit_dasm.h"
30
31/* ------------------------------------------------------------------------ */
32
33/* Get target of combined JMP op. */
34static int jit_jmp_target(jit_State *J)
35{
36 J->combine++;
37 jit_assert(GET_OPCODE(*J->nextins)==OP_JMP);
38 return J->nextpc + 1 + GETARG_sBx(*J->nextins);
39}
40
41/* ------------------------------------------------------------------------ */
42
43/* Include pre-processed architecture-specific backend. */
44#if defined(__i386) || defined(__i386__) || defined(_M_IX86)
45#ifndef LUA_NUMBER_DOUBLE
46#error "No support for other number types on x86 (yet)"
47#endif
48#include "ljit_x86.h"
49#else
50#error "No support for this architecture (yet)"
51#endif
52
53/* ------------------------------------------------------------------------ */
54
55/* Compile instruction range. */
56static void jit_compile_irange(jit_State *J, int firstpc, int lastpc)
57{
58 J->combine = 0;
59 J->nextpc = firstpc;
60 J->nextins = J->pt->code + (firstpc-1);
61 while (J->nextpc <= lastpc) {
62 Instruction ins = *J->nextins++;
63 OpCode op = GET_OPCODE(ins);
64 int ra = GETARG_A(ins);
65 int rb = GETARG_B(ins);
66 int rc = GETARG_C(ins);
67 int rbx = GETARG_Bx(ins);
68 const TValue *combinehint;
69
70 jit_ins_start(J);
71 J->nextpc++;
72
73 combinehint = hint_get(J, COMBINE);
74 if (ttisboolean(combinehint)) {
75 if (bvalue(combinehint)) { /* COMBINE = true: combine with next ins. */
76 if (!(J->flags & JIT_F_DEBUG)) /* But not when debugging. */
77 J->combine = 1;
78 } else { /* COMBINE = false: dead instruction. */
79 *J->mfm++ = JIT_MFM_DEAD;
80 continue;
81 }
82 } /* Other COMBINE hint value types are not defined (yet). */
83
84 if (J->flags & JIT_F_DEBUG_INS)
85 jit_ins_debug(J, luaG_checkopenop(ins));
86
87 switch (op) {
88 case OP_MOVE: jit_op_move(J, ra, rb); break;
89 case OP_LOADK: jit_op_loadk(J, ra, rbx); break;
90 case OP_LOADBOOL: jit_op_loadbool(J, ra, rb, rc); break;
91 case OP_LOADNIL: jit_op_loadnil(J, ra, rb); break;
92
93 case OP_GETUPVAL: jit_op_getupval(J, ra, rb); break;
94 case OP_SETUPVAL: jit_op_setupval(J, ra, rb); break;
95
96 case OP_GETGLOBAL: jit_op_getglobal(J, ra, rbx); break;
97 case OP_SETGLOBAL: jit_op_setglobal(J, ra, rbx); break;
98
99 case OP_NEWTABLE: jit_op_newtable(J, ra, rb, rc); break;
100 case OP_GETTABLE: jit_op_gettable(J, ra, rb, rc); break;
101 case OP_SETTABLE: jit_op_settable(J, ra, rb, rc); break;
102 case OP_SELF: jit_op_self(J, ra, rb, rc); break;
103 case OP_SETLIST: jit_op_setlist(J, ra, rb, rc); break;
104
105 case OP_ADD: jit_op_arith(J, ra, rb, rc, TM_ADD); break;
106 case OP_SUB: jit_op_arith(J, ra, rb, rc, TM_SUB); break;
107 case OP_MUL: jit_op_arith(J, ra, rb, rc, TM_MUL); break;
108 case OP_DIV: jit_op_arith(J, ra, rb, rc, TM_DIV); break;
109 case OP_MOD: jit_op_arith(J, ra, rb, rc, TM_MOD); break;
110 case OP_POW: jit_op_arith(J, ra, rb, rc, TM_POW); break;
111 case OP_UNM: jit_op_arith(J, ra, rb, rb, TM_UNM); break; /* rc unused. */
112
113 case OP_LEN: jit_op_len(J, ra, rb); break;
114 case OP_NOT: jit_op_not(J, ra, rb); break;
115
116 case OP_CONCAT: jit_op_concat(J, ra, rb, rc); break;
117
118 case OP_EQ: jit_op_eq(J, ra, rb, rc); break;
119 case OP_LT: jit_op_arith(J, ra, rb, rc, TM_LT); break;
120 case OP_LE: jit_op_arith(J, ra, rb, rc, TM_LE); break;
121
122 case OP_TEST: jit_op_test(J, rc, ra, ra); break;
123 case OP_TESTSET: jit_op_test(J, rc, ra, rb); break;
124
125 case OP_JMP: jit_op_jmp(J, J->nextpc + rbx-MAXARG_sBx); break;
126
127 case OP_CALL: jit_op_call(J, ra, rb-1, rc-1); break;
128 case OP_TAILCALL: jit_op_tailcall(J, ra, rb-1); break;
129 case OP_RETURN: jit_op_return(J, ra, rb-1); break;
130
131 case OP_FORLOOP: jit_op_forloop(J, ra, J->nextpc + rbx-MAXARG_sBx); break;
132 case OP_FORPREP: jit_op_forprep(J, ra, J->nextpc + rbx-MAXARG_sBx); break;
133
134 case OP_TFORLOOP: jit_op_tforloop(J, ra, rc); break;
135
136 case OP_CLOSE: jit_op_close(J, ra); break;
137 case OP_CLOSURE: jit_op_closure(J, ra, rbx); break;
138
139 case OP_VARARG: jit_op_vararg(J, ra, rb-1); break;
140
141 default: jit_assert(0); break;
142 }
143
144 /* Convention: all opcodes start and end with the .code section. */
145 if (dasm_checkstep(Dst, DASM_SECTION_CODE)) { J->nextpc--; return; }
146
147 *J->mfm++ = 0; /* Placeholder mfm entry. Replaced later. */
148 if (J->combine > 0) { /* Combine next J->combine ins with prev ins. */
149 J->nextpc += J->combine;
150 J->nextins += J->combine;
151 do { *J->mfm++ = JIT_MFM_COMBINE; } while (--J->combine);
152 }
153 }
154}
155
156/* Merge temporary mfm (forward) with PC labels to inverse mfm in mcode. */
157static void jit_mfm_merge(jit_State *J, jit_Mfm *from, jit_Mfm *to, int maxpc)
158{
159 int pc = 1, ofs = 0;
160 for (;;) {
161 int m = *from++;
162 if (m & JIT_MFM_MARK) {
163 switch (m) {
164 default: pc = m ^ JIT_MFM_MARK; break;
165 case JIT_MFM_COMBINE: case JIT_MFM_DEAD: break;
166 case JIT_MFM_STOP: return;
167 }
168 } else {
169 int idx, nofs;
170 for (idx = 0; from[idx] == JIT_MFM_COMBINE; idx++) ;
171 idx += pc;
172 if (idx == J->nextpc) idx = maxpc + 1;
173 nofs = dasm_getpclabel(Dst, idx);
174 m = nofs - ofs;
175 ofs = nofs;
176 jit_assert(nofs >= 0 && m >= 0 && m < JIT_MFM_MAX);
177 }
178 pc++;
179 *to-- = m;
180 }
181}
182
183/* Compile function prototype. */
184static int jit_compile_proto(jit_State *J, Table *deopt)
185{
186 jit_Mfm *tempmfm;
187 void *mcode;
188 size_t sz;
189 int firstpc = 0, maxpc = J->pt->sizecode;
190 int deoptidx = 1;
191 int status;
192 /* (Ab)use the global string concatenation buffer for the temporary mfm. */
193 /* Caveat: the GC must not be run while the backend is active. */
194 tempmfm = (jit_Mfm *)luaZ_openspace(J->L, &G(J->L)->buff,
195 (1+maxpc+1+1+1)*sizeof(jit_Mfm));
196nextdeopt:
197 J->mfm = tempmfm;
198 J->tflags = 0;
199 /* Setup DynASM. */
200 dasm_growpc(Dst, 1+maxpc+2); /* See jit_ins_last(). */
201 dasm_setup(Dst, jit_actionlist);
202 if (deopt) { /* Partial deoptimization. */
203 /* TODO: check deopt chain length? problem: pairs TFOR_CTL migration. */
204 int pc, lastpc;
205 lua_Number n;
206 const TValue *obj = luaH_getnum(deopt, deoptidx++);
207 if (ttisnil(obj) && deoptidx != 2) return JIT_S_OK;
208 if (!ttisnumber(obj)) return JIT_S_COMPILER_ERROR;
209 n = nvalue(obj);
210 lua_number2int(pc, n);
211 firstpc = JIT_IH_IDX(pc);
212 lastpc = firstpc + JIT_IH_LIB(pc);
213 if (firstpc < 1 || firstpc > maxpc || lastpc > maxpc ||
214 J->pt->jit_szmcode == 0)
215 return JIT_S_COMPILER_ERROR;
216 *J->mfm++ = JIT_MFM_MARK+firstpc; /* Seek to firstpc. */
217 jit_compile_irange(J, firstpc, lastpc);
218 jit_assert(J->nextpc == lastpc+1); /* Problem with combined ins? */
219 if (J->nextpc <= maxpc) jit_ins_chainto(J, J->nextpc);
220 *J->mfm++ = JIT_MFM_MARK+maxpc+1; /* Seek to .deopt/.tail. */
221 for (pc = 1; pc <= maxpc; pc++)
222 if (dasm_getpclabel(Dst, pc) == -1) { /* Undefind label referenced? */
223 jit_ins_setpc(J, pc, luaJIT_findmcode(J->pt, pc)); /* => Old mcode. */
224 }
225 } else { /* Full compile. */
226 *J->mfm++ = 0; /* Placeholder mfm entry for prologue. */
227 jit_prologue(J);
228 jit_compile_irange(J, 1, maxpc);
229 }
230 *J->mfm++ = 0; /* Placeholder mfm entry for .deopt/.tail. */
231 *J->mfm = JIT_MFM_STOP;
232 jit_ins_last(J, maxpc, (char *)J->mfm - (char *)tempmfm);
233
234 status = luaJIT_link(J, &mcode, &sz);
235 if (status != JIT_S_OK)
236 return status;
237
238 jit_mfm_merge(J, tempmfm, JIT_MCMFM(mcode, sz), maxpc);
239
240 if (deopt) {
241 jit_MCTrailer tr;
242 /* Patch first instruction to jump to the deoptimized code. */
243 jit_patch_jmp(J, luaJIT_findmcode(J->pt, firstpc), mcode);
244 /* Mark instruction as deoptimized in main mfm. */
245 JIT_MCMFM(J->pt->jit_mcode, J->pt->jit_szmcode)[-firstpc] |= JIT_MFM_MARK;
246 /* Chain deopt mcode block between main mfm and existing mfms. */
247 memcpy(JIT_MCTRAILER(mcode, sz),
248 JIT_MCTRAILER(J->pt->jit_mcode, J->pt->jit_szmcode),
249 sizeof(jit_MCTrailer));
250 tr.mcode = (char *)mcode;
251 tr.sz = sz;
252 memcpy(JIT_MCTRAILER(J->pt->jit_mcode, J->pt->jit_szmcode), (void *)&tr,
253 sizeof(jit_MCTrailer));
254 goto nextdeopt;
255 }
256
257 if (J->pt->jit_szmcode != 0) { /* Full recompile? */
258 jit_MCTrailer tr;
259 /* Patch old mcode entry so other closures get the new callgate. */
260 jit_patch_jmp(J, J->pt->jit_mcode, J->jsub[JSUB_GATE_JL]);
261 /* Chain old main mfm after new main mfm. */
262 tr.mcode = (char *)J->pt->jit_mcode;
263 tr.sz = J->pt->jit_szmcode;
264 memcpy(JIT_MCTRAILER(mcode, sz), (void *)&tr, sizeof(jit_MCTrailer));
265 }
266 /* Set new main mcode block. */
267 J->pt->jit_mcode = mcode;
268 J->pt->jit_szmcode = sz;
269 return JIT_S_OK;
270}
271
272/* ------------------------------------------------------------------------ */
273
274/* Compiler backend. */
275int luaJIT_backend(lua_State *L)
276{
277 jit_State *J = G(L)->jit_state;
278 const TValue *cl;
279 int status = JIT_S_COMPILER_ERROR;
280 lua_lock(L);
281 /* Remember compiler state table. */
282 jit_assert(L->top > L->base && ttistable(L->top-1));
283 J->comstate = hvalue(L->top-1);
284 /* Fetch prototoype. Better check this in case some handler screwed up. */
285 cl = luaH_getstr(J->comstate, luaS_newliteral(L, "func"));
286 if (isLfunction(cl)) {
287 J->pt = clvalue(cl)->l.p;
288 if (J->pt->sizecode > LUAJIT_LIM_BYTECODE) { /* Hard backend limit. */
289 status = JIT_S_TOOLARGE;
290 } else {
291 const TValue *obj = luaH_getstr(J->comstate,
292 luaS_newliteral(J->L, "deopt"));
293 status = jit_compile_proto(J, ttistable(obj) ? hvalue(obj) : (Table *)0);
294 }
295 }
296 lua_unlock(L);
297 J->comstate = NULL; /* Just in case. */
298 J->pt = NULL;
299 if (status == JIT_S_OK) {
300 return 0;
301 } else {
302 if (status == JIT_S_DASM_ERROR) {
303 lua_pushinteger(L, J->nextpc);
304 lua_setfield(L, 1, "dasm_pc");
305 lua_pushinteger(L, J->dasmstatus);
306 lua_setfield(L, 1, "dasm_err");
307 }
308 lua_pushinteger(L, status);
309 return 1;
310 }
311}
312
313/* Initialize compiler backend. */
314int luaJIT_initbackend(lua_State *L)
315{
316 jit_State *J = G(L)->jit_state;
317 J->L = L;
318 J->pt = NULL; /* Not in use. */
319 J->D = NULL;
320 J->mcodeheap = NULL;
321 J->jsubmcode = NULL;
322 J->szjsubmcode = 0;
323 J->numjsub = JSUB__MAX;
324 J->jsub = luaM_newvector(J->L, JSUB__MAX, void *);
325 memset((void *)J->jsub, 0, JSUB__MAX*sizeof(void *)); /* Just in case. */
326 dasm_init(Dst, DASM_MAXSECTION);
327 dasm_setupglobal(Dst, J->jsub, JSUB__MAX);
328 return jit_compile_jsub(J);
329}
330
331/* Free compiler backend. */
332void luaJIT_freebackend(lua_State *L)
333{
334 jit_State *J = G(L)->jit_state;
335 J->L = L;
336 if (J->jsub) luaM_freearray(L, J->jsub, JSUB__MAX, void *);
337 luaJIT_freemcodeheap(J); /* Frees JSUB mcode, too. */
338 dasm_free(Dst);
339}
340
341/* ------------------------------------------------------------------------ */
342
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_core.c b/libraries/LuaJIT-1.1.7/src/ljit_core.c
new file mode 100644
index 0000000..f7385f2
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_core.c
@@ -0,0 +1,385 @@
1/*
2** Interface to JIT engine.
3** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
4*/
5
6#define ljit_core_c
7#define LUA_CORE
8
9#include <string.h>
10
11#include "lua.h"
12
13#include "lobject.h"
14#include "lstate.h"
15#include "ldo.h"
16#include "lstring.h"
17#include "ltable.h"
18#include "ldebug.h"
19#include "lopcodes.h"
20
21#include "ljit.h"
22#include "ljit_hints.h"
23#include "luajit.h"
24
25const char luajit_ident[] =
26 "$LuaJIT: " LUAJIT_VERSION " " LUAJIT_COPYRIGHT " " LUAJIT_URL " $\n";
27
28/* ------------------------------------------------------------------------ */
29
30/* Initialize JIT engine state. */
31void luaJIT_initstate(lua_State *L)
32{
33 jit_State *J = luaM_new(L, jit_State);
34 G(L)->jit_state = J;
35 /* Clear JIT engine fields. */
36 J->frontwrap = NULL; /* Filled in by ljitlib before enabling the engine. */
37 J->flags = 0; /* Disable the JIT engine by default. */
38 /* Try to initialize the backend. */
39 if (luaJIT_initbackend(L) != JIT_S_OK)
40 J->flags = JIT_F_INIT_FAILED;
41 J->L = NULL; /* No compiler thread allocated, yet. */
42}
43
44/* Free JIT engine state. */
45void luaJIT_freestate(lua_State *L)
46{
47 jit_State *J = G(L)->jit_state;
48 if (J == NULL) return;
49 luaJIT_freebackend(L);
50 luaM_free(L, J);
51 G(L)->jit_state = NULL;
52}
53
54/* ------------------------------------------------------------------------ */
55
56/* Find relative PC (0 based) for a bytecode pointer or a JIT mcode address. */
57int luaJIT_findpc(Proto *pt, const Instruction *savedpc)
58{
59 ptrdiff_t pcdiff = savedpc - pt->code;
60 if (pcdiff >= 0 && pcdiff <= pt->sizecode) { /* Bytecode pointer? */
61 return (int)pcdiff-1;
62 } else { /* Else translate JIT mcode address to PC. */
63 char *addr = (char *)savedpc;
64 jit_MCTrailer tr;
65 tr.mcode = (char *)pt->jit_mcode;
66 tr.sz = pt->jit_szmcode;
67 /* Follow trailer chain until addr is part of an mcode block. */
68 while (!((size_t)(addr - tr.mcode) < tr.sz)) {
69 memcpy((void *)&tr, JIT_MCTRAILER(tr.mcode, tr.sz),
70 sizeof(jit_MCTrailer));
71 if (tr.mcode == NULL) return -1; /* Not in chain. */
72 }
73 {
74 jit_Mfm *mfm = JIT_MCMFM(tr.mcode, tr.sz);
75 int ofs = (int)(addr - tr.mcode);
76 int isdeopt = !jit_mfm_ismain(mfm);
77 int pc = 0; /* Prologue fragment is at start of main mfm. */
78 while (pc <= pt->sizecode) {
79 int m = *mfm--;
80 switch (m) {
81 default:
82 if (m & JIT_MFM_MARK) {
83 m ^= JIT_MFM_MARK;
84 if (isdeopt) { pc = m; continue; } /* Seek. */
85 }
86 ofs -= m;
87 if (ofs <= 0) return pc-1; /* Found! */
88 case JIT_MFM_COMBINE:
89 case JIT_MFM_DEAD:
90 pc++;
91 break;
92 case JIT_MFM_STOP:
93 jit_assert(0); /* Premature STOP found. */
94 return -1;
95 }
96 }
97 jit_assert(0); /* Address is in .tail. */
98 return -1;
99 }
100 }
101}
102
103/* Lookup mcode address for PC (1 based) in mfm. */
104static void *jit_mfmlookup(jit_Mfm *mfm, char *addr, int mpc)
105{
106 int isdeopt = !jit_mfm_ismain(mfm);
107 int pc = 0; /* Prologue fragment is at start of main mfm. */
108 while (pc != mpc) {
109 int m = *mfm--;
110 switch (m) {
111 default:
112 if (m & JIT_MFM_MARK) {
113 m ^= JIT_MFM_MARK;
114 if (isdeopt) { pc = m; continue; } /* Seek. */
115 }
116 addr += m;
117 case JIT_MFM_COMBINE:
118 case JIT_MFM_DEAD:
119 pc++;
120 break;
121 case JIT_MFM_STOP:
122 return NULL;
123 }
124 }
125 return (void *)addr;
126}
127
128/* Find mcode address for PC (1 based). */
129void *luaJIT_findmcode(Proto *pt, int pc)
130{
131 void *addr = NULL;
132 jit_Mfm *mfm;
133 jit_MCTrailer tr;
134 tr.mcode = (char *)pt->jit_mcode;
135 tr.sz = pt->jit_szmcode;
136 mfm = JIT_MCMFM(tr.mcode, tr.sz);
137 jit_assert(pc >= 1 && pc <= pt->sizecode);
138 while (mfm[-pc] == JIT_MFM_COMBINE) pc--;
139 while (mfm[-pc] == JIT_MFM_DEAD) pc++;
140 jit_assert(pc >= 1 && mfm[-pc] < (JIT_MFM_MARK|JIT_MFM_MAX)); /* Valid? */
141 if (jit_mfm_isdeoptpc(mfm, pc)) { /* Deoptimized instruction. */
142 do { /* Search through deopt mfm chain. */
143 memcpy((void *)&tr, JIT_MCTRAILER(tr.mcode, tr.sz),
144 sizeof(jit_MCTrailer));
145 if (tr.mcode == NULL) break; /* Deopt ins missing in chain. */
146 mfm = JIT_MCMFM(tr.mcode, tr.sz);
147 if (jit_mfm_ismain(mfm)) break; /* Old main mfm stops search, too. */
148 addr = jit_mfmlookup(mfm, tr.mcode, pc);
149 } while (addr == NULL);
150 } else { /* Not deoptimized. Lookup in main mfm. */
151 addr = jit_mfmlookup(mfm, tr.mcode, pc);
152 }
153 jit_assert(addr != NULL); /* Corrupt mfm chain. */
154 return addr;
155}
156
157/* ------------------------------------------------------------------------ */
158
159/* Compile a prototype. */
160/* Note: func pointer may be invalidated because of stack reallocation. */
161static int jit_compile(lua_State *L, StkId func, Table *st, int force)
162{
163 jit_State *J = G(L)->jit_state;
164 Closure *cl = clvalue(func);
165 Proto *pt = cl->l.p;
166 int status;
167
168 /* Check if JIT engine is enabled and prevent recursive invocation. */
169 if ((J->flags & JIT_F_INIT_FAILED) ||
170 (!force && !(J->flags & JIT_F_ON)) ||
171 !J->frontwrap) {
172 status = JIT_S_ENGINE_OFF;
173 } else if (J->flags & JIT_F_COMPILING) {
174 status = JIT_S_DELAYED;
175 } else if (pt->jit_szmcode != 0 && force < 2) { /* Prevent recompile. */
176 /* TODO: Allow recompiles? Use case? Extra flag for jit.compile()? */
177 status = JIT_S_OK;
178 } else {
179 setclvalue(L, luaH_setstr(L, st, luaS_newliteral(L, "func")), cl);
180 /* Call frontend wrapper. */
181 J->flags |= JIT_F_COMPILING;
182 lua_unlock(L);
183 status = J->frontwrap(L, st);
184 lua_lock(L);
185 J->flags &= ~JIT_F_COMPILING;
186 }
187
188 /* Better sanity check what the frontend returns. */
189 if ((status == JIT_S_OK && pt->jit_szmcode == 0) || status == JIT_S_NONE)
190 status = JIT_S_COMPILER_ERROR;
191
192 /* Update closure callgate and prototype status. */
193 cl->l.jit_gate = (status == JIT_S_OK) ? (lua_CFunction)pt->jit_mcode :
194 G(L)->jit_gateJL;
195 pt->jit_status = status;
196 return status;
197}
198
199/* Create the state table and copy the arguments. */
200static Table *jit_createstate(lua_State *L, StkId arg, int nargs)
201{
202 Table *st = luaH_new(L, nargs, COMSTATE_PREALLOC);
203 int i;
204 for (i = 0; i < nargs; i++)
205 setobj2t(L, luaH_setnum(L, st, i+1), arg+i);
206 return st;
207}
208
209/* ------------------------------------------------------------------------ */
210
211/* Compile and run a function. To be used by luaD_precall() only. */
212int luaJIT_run(lua_State *L, StkId func, int nresults)
213{
214 ptrdiff_t funcr = savestack(L, func);
215 Table *st = jit_createstate(L, func+1, L->top-(func+1));
216 int status = jit_compile(L, func, st, 0); /* Compile function. */
217 func = restorestack(L, funcr);
218
219 /* Run the compiled function on success. Fallback to bytecode on failure. */
220 if (status == JIT_S_OK)
221 return G(L)->jit_gateLJ(L, func, nresults);
222 else
223 return luaD_precall(L, func, nresults);
224 /* Note: We are called from luaD_precall and we call it again. */
225 /* So jit_compile makes sure pt->jit_status != JIT_S_NONE. */
226}
227
228/* ------------------------------------------------------------------------ */
229
230/* No more than two ranges for a single deoptimization right now. */
231#define DEOPTRANGE_ALLOC 2
232
233/* Find PC range of combined instructions and return a range hint. */
234static int combinedrange(jit_Mfm *mfm, int pc)
235{
236 int lastpc = pc;
237 while (mfm[-pc] == JIT_MFM_COMBINE) pc--; /* 1st comb. ins. */
238 while (mfm[-(lastpc+1)] == JIT_MFM_COMBINE) lastpc++; /* Last comb. ins. */
239 return JIT_IH_MKIDX(lastpc-pc, pc); /* (#ins-1, pc) in hint format. */
240}
241
242/* Process deoptimization hints for the given PC range. */
243static int deopthints(Proto *pt, jit_Mfm *dh, TValue *dhint, int pcrange)
244{
245 int m;
246 setnvalue(dhint++, (lua_Number)pcrange);
247 while ((m = *dh--) != JIT_MFM_STOP) {
248 if ((unsigned int)(m - JIT_IH_IDX(pcrange)) <=
249 (unsigned int)JIT_IH_LIB(pcrange)) {
250 switch (*dh--) {
251 case JIT_MFM_DEOPT_PAIRS: /* CALL [i]pairs(): deopt TFORLOOP+JMP. */
252 if (GET_OPCODE(pt->code[m+1-1]) == OP_JMP) {
253 int tfpc = m+2 + GETARG_sBx(pt->code[m+1-1]);
254 if ((unsigned)tfpc < (unsigned)pt->sizecode &&
255 GET_OPCODE(pt->code[tfpc-1]) == OP_TFORLOOP) {
256 setnvalue(dhint++, (lua_Number)JIT_IH_MKIDX(1, tfpc));
257 break;
258 }
259 }
260 return 1; /* Bad hint. */
261 default:
262 return 1; /* Cannot tolerate unknown deoptimization hints. */
263 }
264 }
265 }
266 return 0; /* Ok. */
267}
268
269/* Deoptimize the current instruction. Return new mcode addr to continue. */
270void *luaJIT_deoptimize(lua_State *L)
271{
272 StkId func = L->ci->func;
273 Proto *pt = clvalue(func)->l.p;
274 int pc = luaJIT_findpc(pt, L->savedpc)+1; /* Get prev. PC (1 based). */
275 jit_Mfm *mfm = JIT_MCMFM(pt->jit_mcode, pt->jit_szmcode);
276 int pcrange = combinedrange(mfm, pc);
277 if (!jit_mfm_isdeoptpc(mfm, JIT_IH_IDX(pcrange))) { /* Not deopt. yet? */
278 Table *st = jit_createstate(L, NULL, 0); /* Don't know original args. */
279 Table *deopt = luaH_new(L, DEOPTRANGE_ALLOC, 0);
280 sethvalue(L, luaH_setstr(L, st, luaS_newliteral(L, "deopt")), deopt);
281 if (deopthints(pt, mfm-(pt->sizecode+2), deopt->array, pcrange) ||
282 jit_compile(L, func, st, 2) != JIT_S_OK)
283 luaG_runerror(L, "deoptimization failed");
284 }
285 return luaJIT_findmcode(pt, pc);
286}
287
288/* ------------------------------------------------------------------------ */
289
290/* API function: Compile a Lua function. Pass arguments as hints. */
291LUA_API int luaJIT_compile(lua_State *L, int nargs)
292{
293 StkId func;
294 Table *st;
295 int status;
296 lua_lock(L);
297 api_check(L, (nargs+1) <= (L->top - L->base));
298 func = L->top - (nargs+1);
299 st = jit_createstate(L, func+1, nargs);
300 status = isLfunction(func) ? jit_compile(L, func, st, 1) : -1;
301 lua_unlock(L);
302 return status;
303}
304
305/* Recursively set the mode for all subroutines. */
306static void rec_setmode(Proto *pt, int on)
307{
308 int i;
309 for (i = 0; i < pt->sizep; i++) {
310 Proto *pti = pt->p[i];
311 pti->jit_status = on ? (pti->jit_szmcode?JIT_S_OK:JIT_S_NONE) : JIT_S_OFF;
312 rec_setmode(pti, on); /* Recurse into proto. */
313 }
314}
315
316/* API function: Set the JIT mode for the whole engine or a function+subs. */
317LUA_API int luaJIT_setmode(lua_State *L, int idx, int mode)
318{
319 jit_State *J = G(L)->jit_state;
320 int mm = mode & LUAJIT_MODE_MASK;
321 if (J->flags & JIT_F_INIT_FAILED) return -1; /* Init failed. */
322 switch (mm) {
323 case LUAJIT_MODE_ENGINE: /* Set mode for JIT engine. */
324 if (mode & LUAJIT_MODE_ON)
325 J->flags |= JIT_F_ON;
326 else
327 J->flags &= ~JIT_F_ON;
328 break;
329 case LUAJIT_MODE_DEBUG: { /* Set debug mode. */
330 int dbg;
331 switch (idx) {
332 case 0: dbg = 0; break;
333 case 1: dbg = JIT_F_DEBUG_CALL; break;
334 case 2: default: dbg = JIT_F_DEBUG_CALL | JIT_F_DEBUG_INS; break;
335 }
336 J->flags = (J->flags & ~JIT_F_DEBUG) | dbg;
337 luaJIT_debugnotify(J);
338 break;
339 }
340 case LUAJIT_MODE_FUNC: /* Set mode for function. */
341 case LUAJIT_MODE_ALLFUNC: /* Set mode for function + subfuncs. */
342 case LUAJIT_MODE_ALLSUBFUNC: { /* Set mode for subfunctions. */
343 StkId func;
344 lua_lock(L);
345 func = idx == 0 ? (L->ci-1)->func :
346 (idx > 0 ? L->base + (idx-1) : L->top + idx);
347 if (isLfunction(func)) {
348 Closure *cl = clvalue(func);
349 Proto *pt = cl->l.p;
350 if (mm != LUAJIT_MODE_ALLSUBFUNC) {
351 if (mode & LUAJIT_MODE_ON) {
352 if (pt->jit_szmcode) { /* Already compiled? */
353 cl->l.jit_gate = (lua_CFunction)pt->jit_mcode; /* Reenable. */
354 pt->jit_status = JIT_S_OK;
355 } else {
356 pt->jit_status = JIT_S_NONE; /* (Re-)enable proto compilation */
357 }
358 } else {
359 cl->l.jit_gate = G(L)->jit_gateJL; /* Default callgate. */
360 pt->jit_status = JIT_S_OFF; /* Disable proto compilation. */
361 /* Note: compiled code must be retained for suspended threads. */
362 }
363 }
364 if (mm != LUAJIT_MODE_FUNC)
365 rec_setmode(pt, mode & LUAJIT_MODE_ON);
366 lua_unlock(L);
367 } else {
368 lua_unlock(L);
369 return 0; /* Failed. */
370 }
371 break;
372 }
373 default:
374 return 0; /* Failed. */
375 }
376 return 1; /* OK. */
377}
378
379/* Enforce (dynamic) linker error for version mismatches. See lua.c. */
380LUA_API void LUAJIT_VERSION_SYM(void)
381{
382}
383
384/* ------------------------------------------------------------------------ */
385
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_dasm.c b/libraries/LuaJIT-1.1.7/src/ljit_dasm.c
new file mode 100644
index 0000000..c2d44ee
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_dasm.c
@@ -0,0 +1,38 @@
1/*
2** Wrapper for architecture-specific DynASM encoder.
3** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
4*/
5
6#define ljit_dasm_c
7#define LUA_CORE
8
9
10#include "lua.h"
11
12#include "ljit.h"
13#include "ljit_dasm.h"
14#include "lmem.h"
15
16
17/* Glue macros for DynASM memory allocation. */
18#define DASM_M_GROW(J, t, p, sz, need) \
19 do { \
20 size_t _sz = (sz), _need = (need); \
21 if (_sz < _need) { \
22 if (_sz < 16) _sz = 16; \
23 while (_sz < _need) _sz += _sz; \
24 (p) = (t *)luaM_realloc_(J->L, (p), (sz), _sz); \
25 (sz) = _sz; \
26 } \
27 } while(0)
28
29#define DASM_M_FREE(J, p, sz) luaM_freemem(J->L, p, sz)
30
31/* Embed architecture-specific DynASM encoder. */
32#if defined(__i386) || defined(__i386__) || defined(_M_IX86)
33#include "dasm_x86.h"
34#else
35#error "No support for this architecture (yet)"
36#endif
37
38
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_dasm.h b/libraries/LuaJIT-1.1.7/src/ljit_dasm.h
new file mode 100644
index 0000000..0a9dd5d
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_dasm.h
@@ -0,0 +1,19 @@
1/*
2** Interface to DynASM engine.
3** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
4*/
5
6#ifndef ljit_dasm_h
7#define ljit_dasm_h
8
9#include "ljit.h"
10
11/* DynASM glue definitions. */
12#define Dst J
13#define Dst_DECL jit_State *J
14#define Dst_REF (J->D)
15#define DASM_FDEF LUAI_FUNC
16
17#include "dasm_proto.h"
18
19#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_hints.h b/libraries/LuaJIT-1.1.7/src/ljit_hints.h
new file mode 100644
index 0000000..23743bc
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_hints.h
@@ -0,0 +1,137 @@
1/*
2** Hints for the JIT compiler backend.
3** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
4*/
5
6#ifdef STRING_HINTS
7#define HH(x, name) #name
8#define HH_START(x) static const char *const hints_##x [] = {
9#define HH_END(x) NULL }
10#else
11#define HH(x, name) JIT_##x##_##name
12#define HH_START(x) enum { JIT_##x##_NONE,
13#define HH_END(x) JIT_##x##_MAX }
14
15/* Macros to access hints. */
16#define JIT_H2NUM(x) ((x) << 16)
17
18#define fhint_get(J, hh) \
19 (luaH_getnum(J->comstate, JIT_H2NUM(JIT_FH_##hh)))
20#define fhint_isset(J, hh) (!ttisnil(fhint_get(J, hh)))
21
22#define hint_getpc(J, hh, pc) \
23 (luaH_getnum(J->comstate, (pc)+JIT_H2NUM(JIT_H_##hh)))
24#define hint_get(J, hh) hint_getpc(J, hh, J->nextpc-1)
25#define hint_issetpc(J, hh, pc) (!ttisnil(hint_getpc(J, hh, pc)))
26#define hint_isset(J, hh) hint_issetpc(J, hh, J->nextpc-1)
27
28#endif
29
30/* Hints for functions. */
31HH_START(FH)
32 HH(FH, NOCLOSE), /* No luaF_close() needed. */
33HH_END(FH);
34
35/* Hints for individual bytecode instruction. */
36HH_START(H)
37 HH(H, COMBINE), /* Combine/dead instruction: true/false. */
38 HH(H, FOR_STEP_K), /* FORPREP/FORLOOP step is const: step. */
39 HH(H, TYPE), /* Type hint: typed object. */
40 HH(H, TYPEKEY), /* Type hint for keys: typed object. */
41 HH(H, INLINE), /* Inline function call: internal index. */
42HH_END(H);
43
44#undef HH
45#undef HH_START
46#undef HH_END
47
48
49/* Avoid multiple inclusion for the following. */
50#ifndef ljit_hints_h
51#define ljit_hints_h
52
53/* Index numbers for inlining C functions. */
54/* CHECK: the index numbers must match with jit.opt_lib. */
55
56#define JIT_IH_LIB(x) ((x) >> 16)
57#define JIT_IH_IDX(x) ((x) & 0xffff)
58#define JIT_IH_MKIDX(l, f) (((l) << 16) | (f))
59
60/* Library index numbers. */
61enum {
62 JIT_IHLIB_INTERNAL,
63 JIT_IHLIB_BASE,
64 JIT_IHLIB_COROUTINE,
65 JIT_IHLIB_STRING,
66 JIT_IHLIB_TABLE,
67 JIT_IHLIB_MATH,
68 JIT_IHLIB__LAST
69};
70
71/* Internal functions. */
72enum {
73 JIT_IH_INTERNAL_RECURSIVE, /* Recursive call. */
74 JIT_IH_INTERNAL__LAST
75};
76
77/* Base library functions. */
78enum {
79 JIT_IH_BASE_PAIRS,
80 JIT_IH_BASE_IPAIRS,
81 JIT_IH_BASE__LAST
82};
83
84/* Coroutine library functions. */
85enum {
86 JIT_IH_COROUTINE_YIELD,
87 JIT_IH_COROUTINE_RESUME,
88 JIT_IH_COROUTINE__LAST
89};
90
91/* String library functions. */
92enum {
93 JIT_IH_STRING_LEN,
94 JIT_IH_STRING_SUB,
95 JIT_IH_STRING_CHAR,
96 JIT_IH_STRING__LAST
97};
98
99/* Table library functions. */
100enum {
101 JIT_IH_TABLE_INSERT,
102 JIT_IH_TABLE_REMOVE,
103 JIT_IH_TABLE_GETN,
104 JIT_IH_TABLE__LAST
105};
106
107/* Math library functions. */
108/* CHECK: order must match with function table for jit_inline_math(). */
109enum {
110 /* 1 arg, 1 result. */
111 /* Partially inlined. Call C function from libm: */
112 JIT_IH_MATH_LOG,
113 JIT_IH_MATH_LOG10,
114 JIT_IH_MATH_EXP,
115 JIT_IH_MATH_SINH,
116 JIT_IH_MATH_COSH,
117 JIT_IH_MATH_TANH,
118 JIT_IH_MATH_ASIN,
119 JIT_IH_MATH_ACOS,
120 JIT_IH_MATH_ATAN,
121 /* Fully inlined: */
122 JIT_IH_MATH_SIN,
123 JIT_IH_MATH_COS,
124 JIT_IH_MATH_TAN,
125 JIT_IH_MATH_CEIL,
126 JIT_IH_MATH_FLOOR,
127 JIT_IH_MATH_ABS,
128 JIT_IH_MATH_SQRT,
129 /* 2 args, 1 result. */
130 JIT_IH_MATH_FMOD,
131 JIT_IH_MATH_ATAN2,
132 JIT_IH_MATH__LAST
133};
134
135#define JIT_IH_MATH__21 JIT_IH_MATH_FMOD
136
137#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_mem.c b/libraries/LuaJIT-1.1.7/src/ljit_mem.c
new file mode 100644
index 0000000..73ade7f
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_mem.c
@@ -0,0 +1,405 @@
1/*
2** Memory management for machine code.
3** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
4*/
5
6#define ljit_mem_c
7#define LUA_CORE
8
9#include <string.h>
10
11#include "lua.h"
12
13#include "lmem.h"
14#include "ldo.h"
15#include "ljit.h"
16#include "ljit_dasm.h"
17
18
19/*
20** Define this if you want to run LuaJIT with valgrind. You will get random
21** errors if you don't. And these errors are usually not caught by valgrind!
22**
23** This macro evaluates to a no-op if not run with valgrind. I.e. you can
24** use the same binary for regular runs, too (without a performance loss).
25*/
26#ifdef USE_VALGRIND
27#include <valgrind/valgrind.h>
28#define MCH_INVALIDATE(ptr, addr) VALGRIND_DISCARD_TRANSLATIONS(ptr, addr)
29#else
30#define MCH_INVALIDATE(ptr, addr) ((void)0)
31#endif
32
33
34/* ------------------------------------------------------------------------ */
35
36#if defined(_WIN32) && !defined(LUAJIT_MCH_USE_MALLOC)
37
38/* Use a private heap with executable memory for Windows. */
39#include <windows.h>
40
41/* No need for serialization. There's already a lock per Lua universe. */
42#ifdef HEAP_CREATE_ENABLE_EXECUTE
43#define MCH_HCFLAGS (HEAP_NO_SERIALIZE|HEAP_CREATE_ENABLE_EXECUTE)
44#else
45#define MCH_HCFLAGS (HEAP_NO_SERIALIZE|0x00040000)
46#endif
47
48/* Free the whole mcode heap. */
49void luaJIT_freemcodeheap(jit_State *J)
50{
51 if (J->mcodeheap) HeapDestroy((HANDLE)J->mcodeheap);
52}
53
54/* Allocate a code block from the mcode heap. */
55static void *mcode_alloc(jit_State *J, size_t sz)
56{
57 void *ptr;
58 if (J->mcodeheap == NULL) {
59 J->mcodeheap = (void *)HeapCreate(MCH_HCFLAGS, 0, 0);
60 if (J->mcodeheap == NULL) luaD_throw(J->L, LUA_ERRMEM);
61 }
62 ptr = HeapAlloc(J->mcodeheap, 0, (sz));
63 if (ptr == NULL) luaD_throw(J->L, LUA_ERRMEM);
64 return ptr;
65}
66
67#define mcode_free(L, J, p, sz) HeapFree(J->mcodeheap, 0, (p))
68
69/* ------------------------------------------------------------------------ */
70
71#elif defined(LUA_USE_POSIX) && !defined(LUAJIT_MCH_USE_MALLOC)
72
73/*
74** Allocate EXECUTABLE memory with mmap() on POSIX systems.
75**
76** There is no standard way to reuse malloc(). So this is a very small,
77** but also very naive memory allocator. This should be ok, because:
78**
79** 1. Most apps only allocate mcode while running and free all on exit.
80**
81** 2. Some apps regularly load/unload a bunch of modules ("stages").
82** Allocs/frees come in groups, so coalescing should work fine.
83**
84** If your app differs, then please elaborate and/or supply code.
85** And no -- including a full blown malloc is NOT an option.
86**
87** Caveat: the mmap()'ed heaps are not freed until exit.
88** This shouldn't be too difficult to add, but I didn't bother.
89*/
90
91#include <sys/types.h>
92#include <sys/mman.h>
93
94/* TODO: move this to luaconf.h */
95#define LUAJIT_MCH_CHUNKSIZE (1<<17) /* 128K */
96
97#if defined(MAP_ANONYMOUS)
98#define MCH_MMFLAGS (MAP_PRIVATE|MAP_ANONYMOUS)
99#elif defined(MAP_ANON)
100#define MCH_MMFLAGS (MAP_PRIVATE|MAP_ANON)
101#else
102/* I'm too lazy to add /dev/zero support for ancient systems. */
103#error "Your OS has no (easy) support for anonymous mmap(). Please upgrade."
104#endif
105
106/* Chunk header. Used for the free chunk list / heap headers. */
107typedef struct MCodeHead {
108 struct MCodeHead *next; /* Next free chunk / 1st head: first free. */
109 struct MCodeHead *prev; /* Prev free chunk / 1st head: next head. */
110 size_t size; /* Size of free chunk / Size of heap. */
111 size_t dummy; /* May or may not overlap with trailer. */
112} MCodeHead;
113
114/* Allocation granularity. Assumes sizeof(void *) >= sizeof(size_t). */
115#define MCH_GRANULARITY (4*sizeof(void *))
116#define MCH_ROUNDSIZE(x) (((x) + MCH_GRANULARITY-1) & -MCH_GRANULARITY)
117#define MCH_ROUNDHEAP(x) (((x) + 4095) & -4096)
118#define MCH_HEADERSIZE MCH_ROUNDSIZE(sizeof(MCodeHead))
119
120/* Trailer flags. */
121#define MCH_USED 1 /* Next chunk is in use. */
122#define MCH_LAST 2 /* Next chunk is the last one. */
123#define MCH_FIRST 4 /* Next chunk is the first one. */
124/* Note: the last chunk of each heap doesn't have a trailer. */
125
126/* Trailer macros. */
127#define MCH_PREVTRAILER(mh) ((size_t *)(mh) - 1)
128#define MCH_TRAILER(mh, sz) ((size_t *)((char *)(mh) + (sz)) - 1)
129#define MCH_TRFLAGS(tr) ((tr) & (MCH_USED|MCH_LAST))
130#define MCH_TRSIZE(tr) ((tr) & ~(MCH_USED|MCH_LAST))
131
132/* Debugging memory allocators is ... oh well. */
133#ifdef MCH_DEBUG
134#include <stdio.h>
135#define MCH_DBGF stderr
136#define MCH_DBG(x) fprintf x
137#else
138#define MCH_DBG(x) ((void)0)
139#endif
140
141/* Free the whole list of mcode heaps. */
142void luaJIT_freemcodeheap(jit_State *J)
143{
144 MCodeHead *mh = (MCodeHead *)J->mcodeheap;
145 while (mh) {
146 MCodeHead *prev = mh->prev; /* Heaps are in the prev chain. */
147#ifdef MCH_DEBUG
148 munmap((void *)mh, mh->size+4096);
149#else
150 munmap((void *)mh, mh->size);
151#endif
152 mh = prev;
153 }
154 J->mcodeheap = NULL;
155}
156
157/* Allocate a new heap of at least the given size. */
158static void mcode_newheap(jit_State *J, size_t sz)
159{
160 MCodeHead *mh, *mhn, *fh;
161 void *ptr;
162
163 /* Ensure minimum size or round up. */
164 if (sz + MCH_HEADERSIZE <= LUAJIT_MCH_CHUNKSIZE)
165 sz = LUAJIT_MCH_CHUNKSIZE;
166 else
167 sz = MCH_ROUNDHEAP(sz + MCH_HEADERSIZE);
168
169#ifdef MCH_DEBUG
170 /* Allocate a new heap plus a guard page. */
171 ptr = mmap(NULL, sz+4096, PROT_READ|PROT_WRITE|PROT_EXEC, MCH_MMFLAGS, -1, 0);
172 if (ptr == MAP_FAILED) luaD_throw(J->L, LUA_ERRMEM);
173 mprotect((char *)ptr+sz, 4096, PROT_NONE);
174#else
175 /* Allocate a new heap. */
176 ptr = mmap(NULL, sz, PROT_READ|PROT_WRITE|PROT_EXEC, MCH_MMFLAGS, -1, 0);
177 if (ptr == MAP_FAILED) luaD_throw(J->L, LUA_ERRMEM);
178#endif
179
180 /* Initialize free chunk. */
181 fh = (MCodeHead *)((char *)ptr + MCH_HEADERSIZE);
182 fh->size = sz - MCH_HEADERSIZE;
183 *MCH_PREVTRAILER(fh) = MCH_LAST | MCH_FIRST; /* Zero size, no coalesce. */
184
185 /* Initialize new heap and make it the first heap. */
186 mh = (MCodeHead *)J->mcodeheap;
187 J->mcodeheap = ptr;
188 mhn = (MCodeHead *)ptr;
189 mhn->prev = mh; /* Heaps are in the prev. chain. */
190 mhn->size = sz;
191 mhn->next = fh; /* Start of free list is always in the first heap. */
192 fh->prev = mhn;
193 if (mh) {
194 fh->next = mh->next; /* Old start of free list. */
195 mh->next = NULL; /* Just in case. */
196 } else {
197 fh->next = NULL; /* No other free chunks yet. */
198 }
199 MCH_DBG((MCH_DBGF, "HEAP %p %5x\n", mhn, sz));
200}
201
202/* Allocate a code block. */
203static void *mcode_alloc(jit_State *J, size_t sz)
204{
205 sz = MCH_ROUNDSIZE(sz + sizeof(size_t));
206 for ( ; ; ) {
207 MCodeHead *mh = (MCodeHead *)J->mcodeheap;
208 if (mh) { /* Got at least one heap so search free list. */
209#ifdef MCH_DEBUG
210 int slen = 0;
211 for (mh = mh->next; mh ; mh = mh->next, slen++)
212#else
213 for (mh = mh->next; mh ; mh = mh->next)
214#endif
215 if (mh->size >= sz) { /* Very naive first fit. */
216 size_t *trailer = MCH_TRAILER(mh, sz);
217 size_t *ptrailer = MCH_PREVTRAILER(mh);
218 if (mh->size == sz) { /* Exact match: just unchain chunk. */
219 mh->prev->next = mh->next;
220 if (mh->next)
221 mh->next->prev = mh->prev;
222 *ptrailer |= MCH_USED;
223 MCH_DBG((MCH_DBGF, "NEW %p %5x FIT #%d%s\n",
224 mh, sz, slen, (*ptrailer & MCH_LAST) ? " LAST" : ""));
225 } else { /* Chunk is larger: rechain remainder chunk. */
226 MCodeHead *fh = (MCodeHead *)((char *)mh + sz);
227 size_t tr;
228 fh->size = mh->size - sz;
229 (fh->prev = mh->prev)->next = fh;
230 if ((fh->next = mh->next) != NULL)
231 fh->next->prev = fh;
232 tr = *ptrailer;
233 if (tr & MCH_LAST) {
234 *ptrailer = (tr & ~MCH_LAST) | MCH_USED;
235 *trailer = sz | MCH_LAST;
236 MCH_DBG((MCH_DBGF, "NEW %p %5x REST %p %5x #%d LAST\n",
237 mh, sz, fh, fh->size, slen));
238 } else {
239 size_t *ftrailer = MCH_TRAILER(fh, fh->size);
240 *ftrailer = MCH_TRFLAGS(*ftrailer) | fh->size;
241 *ptrailer = tr | MCH_USED;
242 *trailer = sz;
243 MCH_DBG((MCH_DBGF, "NEW %p %5x REST %p %5x #%d\n",
244 mh, sz, fh, fh->size, slen));
245 }
246 }
247 return (void *)mh;
248 }
249 }
250 /* No luck. Allocate a new heap. Next loop iteration will succeed. */
251 mcode_newheap(J, sz);
252 }
253}
254
255/* Free a code block. */
256static void mcode_free_(jit_State *J, void *ptr, size_t sz)
257{
258 MCodeHead *mh = (MCodeHead *)ptr;
259 size_t *trailer = MCH_TRAILER(mh, sz);
260 size_t *ptrailer = MCH_PREVTRAILER(mh);
261 size_t tr = *ptrailer;
262
263#ifdef MCH_DEBUG
264 if (!(tr & MCH_USED)) MCH_DBG((MCH_DBGF, "**unused %p %5x\n", ptr, sz));
265#endif
266
267 if (!(tr & MCH_FIRST)) {
268 MCodeHead *ph = (MCodeHead *)((char *)mh - MCH_TRSIZE(tr));
269 size_t *pptrailer = MCH_PREVTRAILER(ph);
270 if (!(*pptrailer & MCH_USED)) { /* Prev free? */
271 if (!(tr & MCH_LAST) && !(*trailer & MCH_USED)) { /* Next free? */
272 /* Coalesce with previous and next chunk. */
273 MCodeHead *nh = (MCodeHead *)((char *)mh + sz);
274 MCH_DBG((MCH_DBGF, "free %p %5x PN %p %5x %p %5x%s\n",
275 mh, sz, ph, ph->size, nh, nh->size,
276 (*trailer & MCH_LAST) ? " last" : ""));
277 if ((nh->prev->next = nh->next) != NULL)
278 nh->next->prev = nh->prev;
279 ph->size += sz + nh->size;
280 if (*trailer & MCH_LAST) {
281 *pptrailer |= MCH_LAST;
282 } else {
283 trailer = MCH_TRAILER(nh, nh->size);
284 *trailer = MCH_TRFLAGS(*trailer) | ph->size;
285 }
286 return;
287 }
288 MCH_DBG((MCH_DBGF, "free %p %5x P- %p %5x%s\n",
289 mh, sz, ph, ph->size,
290 (tr & MCH_LAST) ? " last" : ""));
291 ph->size += sz;
292 if (tr & MCH_LAST)
293 *pptrailer |= MCH_LAST;
294 else
295 *trailer = MCH_TRFLAGS(*trailer) | ph->size;
296 return;
297 }
298 }
299
300 if (!(tr & MCH_LAST) && !(*trailer & MCH_USED)) { /* Next free? */
301 /* Coalesce with next chunk. */
302 MCodeHead *nh = (MCodeHead *)((char *)mh + sz);
303 MCH_DBG((MCH_DBGF, "free %p %5x -N %p %5x%s\n",
304 mh, sz, nh, nh->size, (*trailer & MCH_LAST) ? " last" : ""));
305 (mh->prev = nh->prev)->next = mh;
306 if ((mh->next = nh->next))
307 mh->next->prev = mh;
308 mh->size = nh->size + sz;
309 if (*trailer & MCH_LAST) {
310 *ptrailer = (tr & ~MCH_USED) | MCH_LAST;
311 } else {
312 trailer = MCH_TRAILER(mh, mh->size);
313 *trailer = MCH_TRFLAGS(*trailer) | mh->size;
314 *ptrailer = tr & ~MCH_USED;
315 }
316 } else {
317 /* No coalesce possible, just add to free list. */
318 MCodeHead *fh = (MCodeHead *)J->mcodeheap;
319 MCH_DBG((MCH_DBGF, "free %p %5x --%s\n",
320 mh, sz, (tr & MCH_LAST) ? " last" : ""));
321 if ((mh->next = fh->next))
322 mh->next->prev = mh;
323 fh->next = mh;
324 mh->prev = fh;
325 mh->size = sz;
326 *ptrailer = tr & ~MCH_USED;
327 }
328}
329
330#define mcode_free(L, J, p, sz) \
331 mcode_free_(J, (p), MCH_ROUNDSIZE((sz) + sizeof(size_t)))
332
333/* ------------------------------------------------------------------------ */
334
335#else
336
337/*
338** Fallback to Lua's alloc, i.e. probably malloc().
339**
340** Note: the returned memory is usually not marked executable!
341** Running the code will crash if the CPU/OS checks for this.
342** E.g. on x86 CPUs that support the NX (No eXecute) bit.
343*/
344
345/* There's no heap to free, but the JSUB mcode is. */
346void luaJIT_freemcodeheap(jit_State *J)
347{
348 if (J->jsubmcode) luaM_freemem(J->L, J->jsubmcode, J->szjsubmcode);
349}
350
351#define mcode_alloc(J, sz) luaM_realloc_(J->L, NULL, 0, (sz))
352#define mcode_free(L, J, p, sz) luaM_freemem(L, p, sz)
353
354#endif
355
356/* ------------------------------------------------------------------------ */
357
358/* Free mcode. */
359void luaJIT_freemcode(jit_State *J, void *mcode, size_t sz)
360{
361 mcode_free(J->L, J, mcode, sz);
362}
363
364/* Free JIT structures in function prototype. */
365void luaJIT_freeproto(lua_State *L, Proto *pt)
366{
367 char *mcode = (char *)pt->jit_mcode;
368 size_t sz = pt->jit_szmcode;
369 pt->jit_mcode = NULL;
370 pt->jit_szmcode = 0;
371 while (sz != 0) { /* Free whole chain of mcode blocks for this proto. */
372 jit_MCTrailer next;
373 memcpy((void *)&next, JIT_MCTRAILER(mcode, sz), sizeof(jit_MCTrailer));
374 MCH_INVALIDATE(mcode, sz);
375 mcode_free(L, G(L)->jit_state, mcode, sz);
376 mcode = next.mcode;
377 sz = next.sz;
378 }
379}
380
381/* Link generated code. Return mcode address, size and status. */
382int luaJIT_link(jit_State *J, void **mcodep, size_t *szp)
383{
384 size_t sz;
385 void *mcode;
386
387 /* Pass 2: link sections. */
388 if ((J->dasmstatus = dasm_link(Dst, &sz))) return JIT_S_DASM_ERROR;
389
390 /* Check for hardcoded limit on mcode size. */
391 if (sz > LUAJIT_LIM_MCODE) return JIT_S_TOOLARGE;
392
393 /* TODO: mark mcode readonly when we're done. */
394 mcode = mcode_alloc(J, sz);
395
396 /* Pass 3: encode sections. */
397 if ((J->dasmstatus = dasm_encode(Dst, mcode)) != 0) {
398 mcode_free(J->L, J, mcode, sz);
399 return JIT_S_DASM_ERROR;
400 }
401 *mcodep = mcode;
402 *szp = sz;
403 return JIT_S_OK;
404}
405
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_x86.dasc b/libraries/LuaJIT-1.1.7/src/ljit_x86.dasc
new file mode 100644
index 0000000..f7be91e
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_x86.dasc
@@ -0,0 +1,2457 @@
1/*
2** Bytecode to machine code translation for x86 CPUs.
3** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
4*/
5
6|// Include common definitions and macros.
7|.include ljit_x86.dash
8|
9|// Place actionlist and globals here at the top of the file.
10|.actionlist jit_actionlist
11|.globals JSUB_
12
13/* ------------------------------------------------------------------------ */
14
15/* Arch string. */
16const char luaJIT_arch[] = "x86";
17
18/* Forward declarations for C functions called from jsubs. */
19static void jit_hookins(lua_State *L, const Instruction *newpc);
20static void jit_gettable_fb(lua_State *L, Table *t, StkId dest);
21static void jit_settable_fb(lua_State *L, Table *t, StkId val);
22
23/* ------------------------------------------------------------------------ */
24
25/* Detect CPU features and set JIT flags. */
26static int jit_cpudetect(jit_State *J)
27{
28 void *mcode;
29 size_t sz;
30 int status;
31 /* Some of the jsubs need the flags. So compile this separately. */
32 unsigned int feature;
33 dasm_setup(Dst, jit_actionlist);
34 | // Check for CPUID support first.
35 | pushfd
36 | pop edx
37 | mov ecx, edx
38 | xor edx, 0x00200000 // Toggle ID bit in flags.
39 | push edx
40 | popfd
41 | pushfd
42 | pop edx
43 | xor eax, eax // Zero means no features supported.
44 | cmp ecx, edx
45 | jz >1 // No ID toggle means no CPUID support.
46 |
47 | inc eax // CPUID function 1.
48 | push ebx // Callee-save ebx modified by CPUID.
49 | cpuid
50 | pop ebx
51 | mov eax, edx // Return feature support bits.
52 |1:
53 | ret
54 (void)dasm_checkstep(Dst, DASM_SECTION_CODE);
55 status = luaJIT_link(J, &mcode, &sz);
56 if (status != JIT_S_OK)
57 return status;
58 /* Check feature bits. See the Intel/AMD manuals for the bit definitions. */
59 feature = ((unsigned int (*)(void))mcode)();
60 if (feature & (1<<15)) J->flags |= JIT_F_CPU_CMOV;
61 if (feature & (1<<26)) J->flags |= JIT_F_CPU_SSE2;
62 luaJIT_freemcode(J, mcode, sz); /* We don't need this code anymore. */
63 return JIT_S_OK;
64}
65
66/* Check some assumptions. Should compile to nop. */
67static int jit_consistency_check(jit_State *J)
68{
69 do {
70 /* Force a compiler error for inconsistent structure sizes. */
71 /* Check LUA_TVALUE_ALIGN in luaconf.h, too. */
72 ||int check_TVALUE_SIZE_in_ljit_x86_dash[1+TVALUE_SIZE-sizeof(TValue)];
73 ||int check_TVALUE_SIZE_in_ljit_x86_dash_[1+sizeof(TValue)-TVALUE_SIZE];
74 ((void)check_TVALUE_SIZE_in_ljit_x86_dash[0]);
75 ((void)check_TVALUE_SIZE_in_ljit_x86_dash_[0]);
76 if (LUA_TNIL != 0 || LUA_TBOOLEAN != 1 || PCRLUA != 0) break;
77 if ((int)&(((Node *)0)->i_val) != (int)&(((StkId)0)->value)) break;
78 return JIT_S_OK;
79 } while (0);
80 J->dasmstatus = 999999999; /* Recognizable error. */
81 return JIT_S_COMPILER_ERROR;
82}
83
84/* Compile JIT subroutines (once). */
85static int jit_compile_jsub(jit_State *J)
86{
87 int status = jit_consistency_check(J);
88 if (status != JIT_S_OK) return status;
89 status = jit_cpudetect(J);
90 if (status != JIT_S_OK) return status;
91 dasm_setup(Dst, jit_actionlist);
92 |// Macros to reorder and combine JIT subroutine definitions.
93 |.macro .jsub, name
94 |.capture JSUB // Add the entry point.
95 ||//-----------------------------------------------------------------------
96 ||//->name:
97 | .align 16
98 |->name:
99 |.endmacro
100 |.macro .endjsub; .endcapture; .endmacro
101 |.macro .dumpjsub; .dumpcapture JSUB; .endmacro
102 |
103 |.code
104 |//-----------------------------------------------------------------------
105 | .align 16
106 | // Must be the first JSUB defined or used.
107 |->STACKPTR: // Get stack pointer (for jit.util.*).
108 | lea eax, [esp+aword*1] // But adjust for the return address.
109 | ret
110 |
111 |//-----------------------------------------------------------------------
112 | .align 16
113 |->GATE_LJ: // Lua -> JIT gate. (L, func, nresults)
114 | push ebp
115 | mov ebp, esp
116 | sub esp, LJFRAME_OFFSET
117 | mov SAVER1, BASE
118 | mov BASE, CARG2 // func
119 | mov CARG2, L // Arg used as savereg. Avoids aword*8 stack frame.
120 | mov L, CARG1 // L
121 | mov SAVER2, TOP
122 | mov TOP, L->top
123 | mov LCL, BASE->value
124 | mov CI, L->ci
125 | // Prevent stackless yields. No limit check -- this is not a real C call.
126 | inc word L->nCcalls // short
127 |
128 | call aword LCL->jit_gate // Call the compiled code.
129 |
130 | mov CI, L->ci
131 | mov L->top, TOP // Only correct for LUA_MULTRET.
132 | mov edx, CI->savedpc
133 | mov eax, CARG3 // nresults
134 | mov L->savedpc, edx // L->savedpc = CI->savedpc
135 | mov edx, CI->base
136 | test eax, eax
137 | mov L->base, edx // L->base = CI->base
138 | js >2 // Skip for nresults == LUA_MULTRET.
139 |
140 | TValuemul eax
141 | add BASE, eax
142 | xor ecx, ecx
143 | mov L->top, BASE // L->top = &func[nresults]
144 |1: // No initial check. May use EXTRA_STACK (once).
145 | mov TOP->tt, ecx // Clear unset stack slots.
146 | add TOP, #TOP
147 | cmp TOP, BASE
148 | jb <1
149 |
150 |2:
151 | dec word L->nCcalls // short
152 | mov eax, PCRC
153 | mov TOP, SAVER2
154 | mov BASE, SAVER1
155 | mov L, CARG2
156 | mov esp, ebp
157 | pop ebp
158 | ret
159 |
160 |//-----------------------------------------------------------------------
161 | .align 16
162 |->GATE_JL: // JIT -> Lua callgate.
163 | mov PROTO:edx, LCL->p
164 | cmp dword PROTO:edx->jit_status, JIT_S_OK
165 | jne >1 // Already compiled?
166 |
167 | // Yes, copy callgate to closure (so GATE_JL is not called again).
168 | mov edx, PROTO:edx->jit_mcode
169 | mov LCL->jit_gate, edx
170 | jmp edx // Chain to compiled code.
171 |
172 |1: // Let luaD_precall do the hard work: compile & run or fallback.
173 | sub esp, FRAME_OFFSET
174 | mov eax, CI->savedpc
175 | mov L->ci, CI // May not be in sync for tailcalls.
176 | mov L->top, TOP
177 | mov ARG3, -1 // LUA_MULTRET
178 | mov L->savedpc, eax // luaD_precall expects it there.
179 | mov ARG2, BASE
180 | sub BASE, L->stack // Preserve old BASE (= func).
181 | mov ARG1, L
182 | call &luaD_precall // luaD_precall(L, func, nresults)
183 | test eax,eax // Assumes: PCRLUA == 0
184 | jnz >2 // PCRC? PCRYIELD cannot happen.
185 |
186 | // Returned PCRLUA: need to call the bytecode interpreter.
187 | call &luaV_execute, L, 1
188 | // Indirect yield (L->status == LUA_YIELD) cannot happen.
189 |
190 |2: // Returned PCRC: compile & run done. Frame is already unwound.
191 | add esp, FRAME_OFFSET
192 | add BASE, L->stack // Restore stack-relative pointers BASE and TOP.
193 | mov TOP, L->top
194 | ret
195 |
196 |//-----------------------------------------------------------------------
197 | .align 16
198 |->GATE_JC: // JIT -> C callgate.
199 | lea eax, TOP[LUA_MINSTACK]
200 | sub esp, FRAME_OFFSET
201 | cmp eax, L->stack_last
202 | jae ->GROW_STACK // Stack overflow?
203 | cmp CI, L->end_ci
204 | lea CI, CI[1]
205 | je ->GROW_CI // CI overflow?
206 | mov L->ci, CI
207 | mov CI->func, BASE
208 | mov CI->top, eax
209 | mov CCLOSURE:edx, BASE->value
210 | add BASE, #BASE
211 | mov L->top, TOP
212 | mov L->base, BASE
213 | mov CI->base, BASE
214 | // ci->nresults is not set because we don't use luaD_poscall().
215 |
216 |->GATE_JC_PATCH: // Patch mark for jmp to GATE_JC_DEBUG.
217 |
218 | call aword CCLOSURE:edx->f, L // Call the C function.
219 |
220 |2: // Label used below!
221 | add esp, FRAME_OFFSET
222 | mov CI, L->ci
223 | TValuemul eax // eax = nresults*sizeof(TValue)
224 | mov TOP, CI->func
225 | jz >4 // Skip loop if nresults == 0.
226 | // Yield (-1) cannot happen.
227 | mov BASE, L->top
228 | mov edx, BASE
229 | sub BASE, eax // BASE = &L->top[-nresults]
230 |3: // Relocate [L->top-nresults, L->top) -> [ci->func, ci->func+nresults)
231 | mov eax, [BASE]
232 | add BASE, aword*1
233 | mov [TOP], eax
234 | add TOP, aword*1
235 | cmp BASE, edx
236 | jb <3
237 |
238 |4:
239 | mov BASE, CI->func
240 | sub CI, #CI
241 | mov L->ci, CI
242 | ret
243 |
244 |//-----------------------------------------------------------------------
245 | nop; nop; nop; nop; nop; nop // Save area. See DEBUGPATCH_SIZE.
246 | .align 16
247 |->GATE_JC_DEBUG: // JIT -> C callgate for debugging.
248 | test byte L->hookmask, LUA_MASKCALL // Need to call hook?
249 | jnz >7
250 |6:
251 | call aword CCLOSURE:edx->f, L // Call the C function.
252 |
253 | test byte L->hookmask, LUA_MASKRET // Need to call hook?
254 | jz <2
255 |
256 | // Return hook. TODO: LUA_HOOKTAILRET is not called since tailcalls == 0.
257 | mov BASE, eax // BASE (ebx) is callee-save.
258 | call &luaD_callhook, L, LUA_HOOKRET, -1
259 | mov eax, BASE
260 | jmp <2
261 |
262 |7: // Call hook.
263 | mov BASE, CCLOSURE:edx // BASE (ebx) is callee-save.
264 | call &luaD_callhook, L, LUA_HOOKCALL, -1
265 | mov CCLOSURE:edx, BASE
266 | jmp <6
267 |
268 |//-----------------------------------------------------------------------
269 | .align 16
270 |->GROW_STACK: // Grow stack. Jump from/to prologue.
271 | sub eax, TOP
272 | TValuediv eax // eax = (eax-TOP)/sizeof(TValue).
273 | mov L->top, TOP
274 | sub BASE, L->stack
275 | mov ARG3, CI
276 | call &luaD_growstack, L, eax
277 | mov CI, ARG3 // CI may not be in sync with L->ci.
278 | add BASE, L->stack // Restore stack-relative pointers.
279 | mov TOP, L->top
280 | mov LCL, BASE->value
281 | add esp, FRAME_OFFSET // Undo esp adjust of prologue/GATE_JC.
282 | jmp aword LCL->jit_gate // Retry prologue.
283 |
284 |//-----------------------------------------------------------------------
285 | .align 16
286 |->GROW_CI: // Grow CI. Jump from/to prologue.
287 | mov L->top, TOP // May throw LUA_ERRMEM, so save TOP.
288 | call &luaD_growCI, L
289 | lea CI, CINFO:eax[-1] // Undo ci++ (L->ci reset in prologue).
290 | mov LCL, BASE->value
291 | mov L->ci, CI
292 | add esp, FRAME_OFFSET // Undo esp adjust of prologue/GATE_JC.
293 | jmp aword LCL->jit_gate // Retry prologue.
294 |
295 |//-----------------------------------------------------------------------
296 |.dumpjsub // Dump all captured .jsub's.
297 |
298 |// Uncritical jsubs follow. No need to align them.
299 |//-----------------------------------------------------------------------
300 |->DEOPTIMIZE_CALLER: // Deoptimize calling instruction.
301 | pop edx
302 | jmp ->DEOPTIMIZE
303 |
304 |->DEOPTIMIZE_OPEN: // Deoptimize open instruction.
305 | mov L->top, TOP // Save TOP.
306 |
307 |->DEOPTIMIZE: // Deoptimize instruction.
308 | mov L->savedpc, edx // &J->nextins expected in edx.
309 | call &luaJIT_deoptimize, L
310 | mov BASE, L->base
311 | mov TOP, L->top // Restore TOP for open ins.
312 | jmp eax // Continue with new mcode addr.
313 |
314 | .align 16
315 |//-----------------------------------------------------------------------
316
317 (void)dasm_checkstep(Dst, DASM_SECTION_CODE);
318 status = luaJIT_link(J, &J->jsubmcode, &J->szjsubmcode);
319 if (status != JIT_S_OK)
320 return status;
321
322 /* Copy the callgates from the globals to the global state. */
323 G(J->L)->jit_gateLJ = (luaJIT_GateLJ)J->jsub[JSUB_GATE_LJ];
324 G(J->L)->jit_gateJL = (lua_CFunction)J->jsub[JSUB_GATE_JL];
325 G(J->L)->jit_gateJC = (lua_CFunction)J->jsub[JSUB_GATE_JC];
326 return JIT_S_OK;
327}
328
329/* Match with number of nops above. Avoid confusing the instruction decoder. */
330#define DEBUGPATCH_SIZE 6
331
332/* Notify backend that the debug mode may have changed. */
333void luaJIT_debugnotify(jit_State *J)
334{
335 unsigned char *patch = (unsigned char *)J->jsub[JSUB_GATE_JC_PATCH];
336 unsigned char *target = (unsigned char *)J->jsub[JSUB_GATE_JC_DEBUG];
337 /* Yep, this is self-modifying code -- don't tell anyone. */
338 if (patch[0] == 0xe9) { /* Debug patch is active. */
339 if (!(J->flags & JIT_F_DEBUG_CALL)) /* Deactivate it. */
340 memcpy(patch, target-DEBUGPATCH_SIZE, DEBUGPATCH_SIZE);
341 } else { /* Debug patch is inactive. */
342 if (J->flags & JIT_F_DEBUG_CALL) { /* Activate it. */
343 int rel = target-(patch+5);
344 memcpy(target-DEBUGPATCH_SIZE, patch, DEBUGPATCH_SIZE);
345 patch[0] = 0xe9; /* jmp */
346 memcpy(patch+1, &rel, 4); /* Relative address. */
347 memset(patch+5, 0x90, DEBUGPATCH_SIZE-5); /* nop */
348 }
349 }
350}
351
352/* Patch a jmp into existing mcode. */
353static void jit_patch_jmp(jit_State *J, void *mcode, void *to)
354{
355 unsigned char *patch = (unsigned char *)mcode;
356 int rel = ((unsigned char *)to)-(patch+5);
357 patch[0] = 0xe9; /* jmp */
358 memcpy((void *)(patch+1), &rel, 4); /* Relative addr. */
359}
360
361/* ------------------------------------------------------------------------ */
362
363/* Call line/count hook. */
364static void jit_hookins(lua_State *L, const Instruction *newpc)
365{
366 Proto *pt = ci_func(L->ci)->l.p;
367 int pc = luaJIT_findpc(pt, newpc); /* Sloooow with mcode addrs. */
368 const Instruction *savedpc = L->savedpc;
369 L->savedpc = pt->code + pc + 1;
370 if (L->hookmask > LUA_MASKLINE && L->hookcount == 0) {
371 resethookcount(L);
372 luaD_callhook(L, LUA_HOOKCOUNT, -1);
373 }
374 if (L->hookmask & LUA_MASKLINE) {
375 int newline = getline(pt, pc);
376 if (pc != 0) {
377 int oldpc = luaJIT_findpc(pt, savedpc);
378 if (!(pc <= oldpc || newline != getline(pt, oldpc))) return;
379 }
380 luaD_callhook(L, LUA_HOOKLINE, newline);
381 }
382}
383
384/* Insert hook check for each instruction in full debug mode. */
385static void jit_ins_debug(jit_State *J, int openop)
386{
387 if (openop) {
388 | mov L->top, TOP
389 }
390 |// TODO: Passing bytecode addrs would speed this up (but use more space).
391 | call ->HOOKINS
392
393 |.jsub HOOKINS
394 | test byte L->hookmask, LUA_MASKLINE|LUA_MASKCOUNT
395 | jz >2
396 | dec dword L->hookcount
397 | jz >1
398 | test byte L->hookmask, LUA_MASKLINE
399 | jz >2
400 |1:
401 | mov eax, [esp] // Current machine code address.
402 | sub esp, FRAME_OFFSET
403 | call &jit_hookins, L, eax
404 | add esp, FRAME_OFFSET
405 | mov BASE, L->base // Restore stack-relative pointers.
406 | mov TOP, L->top
407 |2:
408 | ret
409 |.endjsub
410}
411
412/* Called before every instruction. */
413static void jit_ins_start(jit_State *J)
414{
415 |// Always emit PC labels, even for dead code (but not for combined JMP).
416 |=>J->nextpc:
417}
418
419/* Chain to another instruction. */
420static void jit_ins_chainto(jit_State *J, int pc)
421{
422 | jmp =>pc
423}
424
425/* Set PC label. */
426static void jit_ins_setpc(jit_State *J, int pc, void *target)
427{
428 |.label =>pc, &target
429}
430
431/* Called after the last instruction has been encoded. */
432static void jit_ins_last(jit_State *J, int lastpc, int sizemfm)
433{
434 if (J->tflags & JIT_TF_USED_DEOPT) { /* Deopt section has been used? */
435 |.deopt
436 | jmp ->DEOPTIMIZE // Yes, need to add final jmp.
437 |.code
438 }
439 |=>lastpc+1: // Extra label at the end of .code.
440 |.tail
441 |=>lastpc+2: // And at the end of .deopt/.tail.
442 | .align word // Keep next section word aligned.
443 | .word 0xffff // Terminate mfm with JIT_MFM_STOP.
444 |.mfmap
445 | // <-- Deoptimization hints are inserted here.
446 | .space sizemfm // To be filled in with inverse mfm.
447 | .aword 0, 0 // Next mcode block pointer and size.
448 | // The previous two awords are only word, but not aword aligned.
449 | // Copying them is easier than aligning them and adjusting mfm handling.
450 |.code
451}
452
453/* Add a deoptimize target for the current instruction. */
454static void jit_deopt_target(jit_State *J, int nargs)
455{
456 |.define L_DEOPTLABEL, 9 // Local deopt label.
457 |.define L_DEOPTIMIZE, <9 // Local deopt target. Use after call.
458 |.define L_DEOPTIMIZEF, >9 // Local deopt target. Use before call.
459 if (nargs != -1) {
460 |// Alas, x86 doesn't have conditional calls. So branch to the .deopt
461 |// section to load J->nextins and jump to JSUB_DEOPTIMIZE.
462 |// Only a single jump is added at the end (if needed) and any
463 |// intervening code sequences are shadowed (lea trick).
464 |.deopt // Occupies 6 bytes in .deopt section.
465 | .byte 0x8d // Shadow mov with lea edi, [edx+ofs].
466 |L_DEOPTLABEL:
467 | mov edx, &J->nextins // Current instruction + 1.
468 |.code
469 J->tflags |= JIT_TF_USED_DEOPT;
470 } else {
471 |.tail // Occupies 10 bytes in .tail section.
472 |L_DEOPTLABEL:
473 | mov edx, &J->nextins
474 | jmp ->DEOPTIMIZE_OPEN // Open ins need to save TOP, too.
475 | // And TOP (edi) would be overwritten by the lea trick.
476 | // So checking for open ops later on wouldn't suffice. Sigh.
477 |.code
478 }
479}
480
481/* luaC_checkGC() inlined. Destroys caller-saves + TOP (edi). Uses label 7:. */
482/* Use this only at the _end_ of an instruction. */
483static void jit_checkGC(jit_State *J)
484{
485 | mov GL:ecx, L->l_G
486 | mov eax, GL:ecx->totalbytes // size_t
487 | mov TOP, >7
488 | cmp eax, GL:ecx->GCthreshold // size_t
489 | jae ->GCSTEP
490 |7:
491
492 |.jsub GCSTEP
493 | call &luaC_step, L
494 | mov BASE, L->base
495 | jmp TOP
496 |.endjsub
497}
498
499/* ------------------------------------------------------------------------ */
500
501|// JIT->JIT calling conventions:
502|//
503|// Register/Type | Call Setup | Prologue | Epilogue | Call Finish
504|// ===========================================================================
505|// eax | LCL | = BASE->value| | * | *
506|// ecx | CI | = L->ci | L->ci = ++CI | * | *
507|// edx | * | * | * | * | *
508|// ---------------------------------------------------------------------------
509|// esi | L | | | |
510|// ebx | BASE | += f | ++ | -- | -= f
511|// edi | TOP | += f+1+nargs | = BASE+maxst | = f+nresults | = BASE+maxst
512|// ---------------------------------------------------------------------------
513|// L->base | | = BASE | | = BASE
514|// L->top | | = TOP | | = TOP
515|// L->ci | | ++, -> = ... | -- |
516|// L->ci->savedpc| = &code[pc] | [ L-> = ] | |
517|// ---------------------------------------------------------------------------
518|// args + vars | | setnil | |
519|// results | | | move | setnil
520|// ---------------------------------------------------------------------------
521
522
523|// Include support for function inlining.
524|.include ljit_x86_inline.dash
525
526
527#ifdef LUA_COMPAT_VARARG
528static void jit_vararg_table(lua_State *L)
529{
530 Table *tab;
531 StkId base, func;
532 int i, num, numparams;
533 luaC_checkGC(L);
534 base = L->base;
535 func = L->ci->func;
536 numparams = clvalue(func)->l.p->numparams;
537 num = base - func - numparams - 1;
538 tab = luaH_new(L, num, 1);
539 for (i = 0; i < num; i++)
540 setobj2n(L, luaH_setnum(L, tab, i+1), base - num + i);
541 setnvalue(luaH_setstr(L, tab, luaS_newliteral(L, "n")), (lua_Number)num);
542 sethvalue(L, base + numparams, tab);
543}
544#endif
545
546/* Encode JIT function prologue. */
547static void jit_prologue(jit_State *J)
548{
549 Proto *pt = J->pt;
550 int numparams = pt->numparams;
551 int stacksize = pt->maxstacksize;
552
553 |// Note: the order of the following instructions has been carefully tuned.
554 | lea eax, TOP[stacksize]
555 | sub esp, FRAME_OFFSET
556 | cmp eax, L->stack_last
557 | jae ->GROW_STACK // Stack overflow?
558 | // This is a slight overallocation (BASE[1+stacksize] would be enough).
559 | // We duplicate luaD_precall() behaviour so we can use luaD_growstack().
560 | cmp CI, L->end_ci
561 | lea CI, CI[1]
562 | je ->GROW_CI // CI overflow?
563 | xor eax, eax // Assumes: LUA_TNIL == 0
564 | mov CI->func, BASE
565 | add BASE, #BASE
566 | mov L->ci, CI
567
568 if (numparams > 0) {
569 | lea edx, BASE[numparams]
570 | cmp TOP, edx // L->top >< L->base+numparams ?
571 }
572
573 if (!pt->is_vararg) { /* Fixarg function. */
574 /* Must cap L->top at L->base+numparams because 1st LOADNIL is omitted. */
575 if (numparams == 0) {
576 | mov TOP, BASE
577 } else if (J->flags & JIT_F_CPU_CMOV) {
578 | cmova TOP, edx
579 } else {
580 | jna >1
581 | mov TOP, edx
582 |1:
583 }
584 | lea edx, BASE[stacksize] // New ci->top.
585 | mov CI->tailcalls, eax // 0
586 | mov CI->top, edx
587 | mov L->top, edx
588 | mov L->base, BASE
589 | mov CI->base, BASE
590 } else { /* Vararg function. */
591 int i;
592 if (numparams > 0) {
593 |// If some fixargs are missing we need to clear them and
594 |// bump TOP to get a consistent frame layout for OP_VARARG.
595 | jb >5
596 |4:
597 |.tail
598 |5: // This is uncommon. So move it to .tail and use a loop.
599 | mov TOP->tt, eax
600 | add TOP, #TOP
601 | cmp TOP, edx
602 | jb <5
603 | jmp <4
604 |.code
605 }
606 | mov L->base, TOP // New base is after last arg.
607 | mov CI->base, TOP
608 | mov CI->tailcalls, eax // 0
609 for (i = 0; i < numparams; i++) { /* Move/clear fixargs. */
610 |// Inline this. Vararg funcs usually have very few fixargs.
611 | copyslot TOP[i], BASE[i], ecx, edx
612 | mov BASE[i].tt, eax // Clear old fixarg slot (help the GC).
613 }
614 if (numparams > 0) {
615 | mov CI, L->ci // Reload CI = ecx (used by move).
616 }
617 | mov BASE, TOP
618 | lea edx, BASE[stacksize] // New ci->top.
619 | lea TOP, BASE[numparams] // Start of vars to clear.
620 | mov CI->top, edx
621 | mov L->top, edx
622 stacksize -= numparams; /* Fixargs are already cleared. */
623 }
624
625 /* Clear undefined args and all vars. Still assumes eax = LUA_TNIL = 0. */
626 /* Note: cannot clear only args because L->top has grown. */
627 if (stacksize <= EXTRA_STACK) { /* Loopless clear. May use EXTRA_STACK. */
628 int i;
629 for (i = 0; i < stacksize; i++) {
630 | mov TOP[i].tt, eax
631 }
632 } else { /* Standard loop. */
633 |2: // Unrolled for 2 stack slots. No initial check. May use EXTRA_STACK.
634 | mov TOP[0].tt, eax
635 | mov TOP[1].tt, eax
636 | add TOP, 2*#TOP
637 | cmp TOP, edx
638 | jb <2
639 |// Note: TOP is undefined now. TOP is only valid across calls/open ins.
640 }
641
642#ifdef LUA_COMPAT_VARARG
643 if (pt->is_vararg & VARARG_NEEDSARG) {
644 | call &jit_vararg_table, L
645 }
646#endif
647
648 /* Call hook check. */
649 if (J->flags & JIT_F_DEBUG_CALL) {
650 | test byte L->hookmask, LUA_MASKCALL
651 | jz >9
652 | call ->HOOKCALL
653 |9:
654
655 |.jsub HOOKCALL
656 | mov CI, L->ci
657 | mov TOP, CI->func
658 | mov LCL, TOP->value
659 | mov PROTO:edi, LCL->p // clvalue(L->ci->func)->l.p
660 | mov eax, PROTO:edi->code
661 | add eax, 4 // Hooks expect incremented PC.
662 | mov L->savedpc, eax
663 | sub esp, FRAME_OFFSET
664 | call &luaD_callhook, L, LUA_HOOKCALL, -1
665 | add esp, FRAME_OFFSET
666 | mov eax, PROTO:edi->code // PROTO:edi is callee-save.
667 | mov L->savedpc, eax // jit_hookins needs previous PC.
668 | mov BASE, L->base
669 | ret
670 |.endjsub
671 }
672}
673
674/* Check if we can combine 'return const'. */
675static int jit_return_k(jit_State *J)
676{
677 if (!J->combine) return 0; /* COMBINE hint set? */
678 /* May need to close open upvalues. */
679 if (!fhint_isset(J, NOCLOSE)) {
680 | call &luaF_close, L, BASE
681 }
682 if (!J->pt->is_vararg) { /* Fixarg function. */
683 | sub aword L->ci, #CI
684 | mov TOP, BASE
685 | sub BASE, #BASE
686 | add esp, FRAME_OFFSET
687 } else { /* Vararg function. */
688 | mov CI, L->ci
689 | mov BASE, CI->func
690 | sub CI, #CI
691 | mov L->ci, CI
692 | lea TOP, BASE[1]
693 | add esp, FRAME_OFFSET
694 }
695 jit_assert(J->combine == 1); /* Required to skip next RETURN instruction. */
696 return 1;
697}
698
699static void jit_op_return(jit_State *J, int rbase, int nresults)
700{
701 /* Return hook check. */
702 if (J->flags & JIT_F_DEBUG_CALL) {
703 if (nresults < 0 && !(J->flags & JIT_F_DEBUG_INS)) {
704 | mov L->top, TOP
705 }
706 |// TODO: LUA_HOOKTAILRET (+ ci->tailcalls counting) or changed debug API.
707 | test byte L->hookmask, LUA_MASKRET
708 | jz >7
709 | call ->HOOKRET
710 |7:
711 if (J->flags & JIT_F_DEBUG_INS) {
712 | mov eax, FRAME_RETADDR
713 | mov L->savedpc, eax
714 }
715
716 |.jsub HOOKRET
717 | mov eax, [esp] // Current machine code address.
718 | mov L->savedpc, eax
719 | sub esp, FRAME_OFFSET
720 | call &luaD_callhook, L, LUA_HOOKRET, -1
721 | add esp, FRAME_OFFSET
722 | mov BASE, L->base // Restore stack-relative pointers.
723 | mov TOP, L->top
724 | ret
725 |.endjsub
726 }
727
728 /* May need to close open upvalues. */
729 if (!fhint_isset(J, NOCLOSE)) {
730 | call &luaF_close, L, BASE
731 }
732
733 /* Previous op was open: 'return f()' or 'return ...' */
734 if (nresults < 0) {
735 |// Relocate [BASE+rbase, TOP) -> [ci->func, *).
736 | mov CI, L->ci
737 | addidx BASE, rbase
738 | mov edx, CI->func
739 | cmp BASE, TOP
740 | jnb >2
741 |1:
742 | mov eax, [BASE]
743 | add BASE, aword*1
744 | mov [edx], eax
745 | add edx, aword*1
746 | cmp BASE, TOP
747 | jb <1
748 |2:
749 | add esp, FRAME_OFFSET
750 | mov BASE, CI->func
751 | sub CI, #CI
752 | mov TOP, edx // Relocated TOP.
753 | mov L->ci, CI
754 | ret
755 return;
756 }
757
758 if (!J->pt->is_vararg) { /* Fixarg function, nresults >= 0. */
759 int i;
760 | sub aword L->ci, #CI
761 |// Relocate [BASE+rbase,BASE+rbase+nresults) -> [BASE-1, *).
762 |// TODO: loop for large nresults?
763 | sub BASE, #BASE
764 for (i = 0; i < nresults; i++) {
765 | copyslot BASE[i], BASE[rbase+i+1]
766 }
767 | add esp, FRAME_OFFSET
768 | lea TOP, BASE[nresults]
769 | ret
770 } else { /* Vararg function, nresults >= 0. */
771 int i;
772 |// Relocate [BASE+rbase,BASE+rbase+nresults) -> [ci->func, *).
773 | mov CI, L->ci
774 | mov TOP, CI->func
775 | sub CI, #CI
776 | mov L->ci, CI // CI = ecx is used by copyslot.
777 for (i = 0; i < nresults; i++) {
778 | copyslot TOP[i], BASE[rbase+i]
779 }
780 | add esp, FRAME_OFFSET
781 | mov BASE, TOP
782 | addidx TOP, nresults
783 | ret
784 }
785}
786
787static void jit_op_call(jit_State *J, int func, int nargs, int nresults)
788{
789 int cltype = jit_inline_call(J, func, nargs, nresults);
790 if (cltype < 0) return; /* Inlined? */
791
792 |// Note: the order of the following instructions has been carefully tuned.
793 | addidx BASE, func
794 | mov CI, L->ci
795 | isfunction 0 // BASE[0] is L->base[func].
796 if (nargs >= 0) { /* Previous op was not open and did not set TOP. */
797 | lea TOP, BASE[1+nargs]
798 }
799 | mov LCL, BASE->value
800 | mov edx, &J->nextins
801 | mov CI->savedpc, edx
802 if (cltype == LUA_TFUNCTION) {
803 if (nargs == -1) {
804 | jne ->DEOPTIMIZE_OPEN // TYPE hint was wrong (open op)?
805 } else {
806 | jne ->DEOPTIMIZE // TYPE hint was wrong?
807 }
808 } else {
809 | je >1 // Skip __call handling for functions.
810 | call ->METACALL
811 |1:
812
813 |.jsub METACALL // CALL to __call metamethod.
814 | sub esp, FRAME_OFFSET
815 | mov L->savedpc, edx // May throw errors. Save PC and TOP.
816 | mov L->top, TOP
817 | call &luaD_tryfuncTM, L, BASE // Resolve __call metamethod.
818 | add esp, FRAME_OFFSET
819 | mov BASE, eax // Restore stack-relative pointers.
820 | mov TOP, L->top
821 | mov LCL, BASE->value
822 | mov CI, L->ci
823 | ret
824 |.endjsub
825 }
826 | call aword LCL->jit_gate // Call JIT func or GATE_JL/GATE_JC.
827 | subidx BASE, func
828 | mov L->base, BASE
829
830 /* Clear undefined results TOP <= o < func+nresults. */
831 if (nresults > 0) {
832 | xor eax, eax
833 if (nresults <= EXTRA_STACK) { /* Loopless clear. May use EXTRA_STACK. */
834 int i;
835 for (i = 0; i < nresults; i++) {
836 | mov TOP[i].tt, eax
837 }
838 } else { /* Standard loop. TODO: move to .tail? */
839 | lea edx, BASE[func+nresults]
840 |1: // Unrolled for 2 stack slots. No initial check. May use EXTRA_STACK.
841 | mov TOP[0].tt, eax // LUA_TNIL
842 | mov TOP[1].tt, eax // LUA_TNIL
843 | add TOP, 2*#TOP
844 | cmp TOP, edx
845 | jb <1
846 }
847 }
848
849 if (nresults >= 0) { /* Not an open ins. Restore L->top. */
850 | lea TOP, BASE[J->pt->maxstacksize] // Faster than getting L->ci->top.
851 | mov L->top, TOP
852 } /* Otherwise keep TOP for next instruction. */
853}
854
855static void jit_op_tailcall(jit_State *J, int func, int nargs)
856{
857 int cltype;
858
859 if (!fhint_isset(J, NOCLOSE)) { /* May need to close open upvalues. */
860 | call &luaF_close, L, BASE
861 }
862
863 cltype = jit_inline_call(J, func, nargs, -2);
864 if (cltype < 0) goto finish; /* Inlined? */
865
866 if (cltype == LUA_TFUNCTION) {
867 jit_deopt_target(J, nargs);
868 | isfunction func
869 | jne L_DEOPTIMIZE // TYPE hint was wrong?
870 } else {
871 | isfunction func; jne >5 // Handle generic callables first.
872 |.tail
873 |5: // Fallback for generic callables.
874 | addidx BASE, func
875 if (nargs >= 0) {
876 | lea TOP, BASE[1+nargs]
877 }
878 | mov edx, &J->nextins
879 | jmp ->METATAILCALL
880 |.code
881
882 |.jsub METATAILCALL // TAILCALL to __call metamethod.
883 | mov L->savedpc, edx
884 | mov L->top, TOP
885 | call &luaD_tryfuncTM, L, BASE // Resolve __call metamethod.
886 |
887 |// Relocate [eax, L->top) -> [L->ci->func, *).
888 | mov CI, L->ci
889 | mov edx, L->top
890 | mov TOP, CI->func
891 |1:
892 | mov BASE, [eax]
893 | add eax, aword*1
894 | mov [TOP], BASE
895 | add TOP, aword*1
896 | cmp eax, edx
897 | jb <1
898 |
899 | mov BASE, CI->func
900 | mov LCL, BASE->value
901 | sub CI, #CI
902 | add esp, FRAME_OFFSET
903 | jmp aword LCL->jit_gate // Chain to callgate.
904 |.endjsub
905 }
906
907 if (nargs >= 0) { /* Previous op was not open and did not set TOP. */
908 int i;
909 /* Relocate [BASE+func, BASE+func+nargs] -> [ci->func, ci->func+nargs]. */
910 /* TODO: loop for large nargs? */
911 if (!J->pt->is_vararg) { /* Fixarg function. */
912 | mov LCL, BASE[func].value
913 for (i = 0; i < nargs; i++) {
914 | copyslot BASE[i], BASE[func+1+i], ecx, edx
915 }
916 | lea TOP, BASE[nargs]
917 | sub BASE, #BASE
918 | mov CI, L->ci
919 | mov BASE->value, LCL // Sufficient to copy func->value.
920 } else { /* Vararg function. */
921 | mov CI, L->ci
922 | lea TOP, BASE[func]
923 | mov BASE, CI->func
924 | mov LCL, TOP->value
925 | mov BASE->value, LCL // Sufficient to copy func->value.
926 for (i = 0; i < nargs; i++) {
927 | copyslot BASE[i+1], TOP[i+1], eax, edx
928 }
929 | lea TOP, BASE[1+nargs]
930 | mov LCL, BASE->value // Need to reload LCL = eax.
931 }
932 } else { /* Previous op was open and set TOP. */
933 |// Relocate [BASE+func, TOP) -> [ci->func, *).
934 | mov CI, L->ci
935 | addidx BASE, func
936 | mov edx, CI->func
937 |1:
938 | mov eax, [BASE]
939 | add BASE, aword*1
940 | mov [edx], eax
941 | add edx, aword*1
942 | cmp BASE, TOP
943 | jb <1
944 | mov BASE, CI->func
945 | mov TOP, edx // Relocated TOP.
946 | mov LCL, BASE->value
947 }
948 | sub CI, #CI
949 | add esp, FRAME_OFFSET
950 | jmp aword LCL->jit_gate // Chain to JIT function.
951
952finish:
953 J->combine++; /* Combine with following return instruction. */
954}
955
956/* ------------------------------------------------------------------------ */
957
958static void jit_op_move(jit_State *J, int dest, int src)
959{
960 | copyslot BASE[dest], BASE[src]
961}
962
963static void jit_op_loadk(jit_State *J, int dest, int kidx)
964{
965 const TValue *kk = &J->pt->k[kidx];
966 int rk = jit_return_k(J);
967 if (rk) dest = 0;
968 | copyconst BASE[dest], kk
969 if (rk) {
970 | ret
971 }
972}
973
974static void jit_op_loadnil(jit_State *J, int first, int last)
975{
976 int idx, num = last - first + 1;
977 int rk = jit_return_k(J);
978 | xor eax, eax // Assumes: LUA_TNIL == 0
979 if (rk) {
980 | settt BASE[0], eax
981 | ret
982 } else if (num <= 8) {
983 for (idx = first; idx <= last; idx++) {
984 | settt BASE[idx], eax // 3/6 bytes
985 }
986 } else {
987 | lea ecx, BASE[first].tt // 15-21 bytes
988 | lea edx, BASE[last].tt
989 |1:
990 | mov [ecx], eax
991 | cmp ecx, edx
992 | lea ecx, [ecx+#BASE] // Preserves CC.
993 | jbe <1
994 }
995}
996
997static void jit_op_loadbool(jit_State *J, int dest, int b, int dojump)
998{
999 int rk = jit_return_k(J);
1000 if (rk) dest = 0;
1001 | setbvalue BASE[dest], b
1002 if (rk) {
1003 | ret
1004 } else if (dojump) {
1005 const TValue *h = hint_getpc(J, COMBINE, J->nextpc);
1006 if (!(ttisboolean(h) && bvalue(h) == 0)) { /* Avoid jmp around dead ins. */
1007 | jmp =>J->nextpc+1
1008 }
1009 }
1010}
1011
1012/* ------------------------------------------------------------------------ */
1013
1014static void jit_op_getupval(jit_State *J, int dest, int uvidx)
1015{
1016 | getLCL
1017 | mov UPVAL:ecx, LCL->upvals[uvidx]
1018 | mov TOP, UPVAL:ecx->v
1019 | copyslot BASE[dest], TOP[0]
1020}
1021
1022static void jit_op_setupval(jit_State *J, int src, int uvidx)
1023{
1024 | getLCL
1025 | mov UPVAL:ecx, LCL->upvals[uvidx]
1026 | mov TOP, UPVAL:ecx->v
1027 | // This is really copyslot TOP[0], BASE[src] with compare mixed in.
1028 | mov eax, BASE[src].tt
1029 | mov GCOBJECT:edx, BASE[src].value
1030 | mov TOP->tt, eax
1031 | cmp eax, LUA_TSTRING // iscollectable(val)?
1032 | mov eax, BASE[src].value.na[1]
1033 | mov TOP->value, GCOBJECT:edx
1034 | mov TOP->value.na[1], eax
1035 | jae >5
1036 |4:
1037 |.tail
1038 |5:
1039 | test byte GCOBJECT:edx->gch.marked, WHITEBITS // && iswhite(val)
1040 | jz <4
1041 | test byte UPVAL:ecx->marked, bitmask(BLACKBIT) // && isblack(uv)
1042 | jz <4
1043 | call ->BARRIERF // Yes, need barrier.
1044 | jmp <4
1045 |.code
1046
1047 |.jsub BARRIERF // luaC_barrierf() with regparms.
1048 | mov ARG4, GCOBJECT:edx
1049 | mov ARG3, UPVAL:ecx
1050 | mov ARG2, L
1051 | jmp &luaC_barrierf // Chain to C code.
1052 |.endjsub
1053}
1054
1055/* ------------------------------------------------------------------------ */
1056
1057/* Optimized table lookup routines. Enter via jsub, fallback to C. */
1058
1059/* Fallback for GETTABLE_*. Temporary key is in L->env. */
1060static void jit_gettable_fb(lua_State *L, Table *t, StkId dest)
1061{
1062 Table *mt = t->metatable;
1063 const TValue *tm = luaH_getstr(mt, G(L)->tmname[TM_INDEX]);
1064 if (ttisnil(tm)) { /* No __index method? */
1065 mt->flags |= 1<<TM_INDEX; /* Cache this fact. */
1066 setnilvalue(dest);
1067 } else if (ttisfunction(tm)) { /* __index function? */
1068 ptrdiff_t destr = savestack(L, dest);
1069 setobj2s(L, L->top, tm);
1070 sethvalue(L, L->top+1, t);
1071 setobj2s(L, L->top+2, &L->env);
1072 luaD_checkstack(L, 3);
1073 L->top += 3;
1074 luaD_call(L, L->top - 3, 1);
1075 dest = restorestack(L, destr);
1076 L->top--;
1077 setobjs2s(L, dest, L->top);
1078 } else { /* Let luaV_gettable() continue with the __index object. */
1079 luaV_gettable(L, tm, &L->env, dest);
1080 }
1081
1082 |//-----------------------------------------------------------------------
1083 |.jsub GETGLOBAL // Lookup global variable.
1084 |// Call with: TSTRING:edx (key), BASE (dest)
1085 | mov CI, L->ci
1086 | mov TOP, CI->func
1087 | mov LCL, TOP->value
1088 | mov TABLE:edi, LCL->env
1089 | jmp >9
1090 |.endjsub
1091 |
1092 |//-----------------------------------------------------------------------
1093 |.jsub GETTABLE_KSTR // Lookup constant string in table.
1094 |// Call with: TOP (tab), TSTRING:edx (key), BASE (dest)
1095 | cmp dword TOP->tt, LUA_TTABLE
1096 | mov TABLE:edi, TOP->value
1097 | jne ->DEOPTIMIZE_CALLER // Not a table? Deoptimize.
1098 |
1099 |// Common entry: TABLE:edi (tab), TSTRING:edx (key), BASE (dest)
1100 |// Restores BASE, destroys eax, ecx, edx, edi (TOP).
1101 |9:
1102 | movzx ecx, byte TABLE:edi->lsizenode // hashstr(t, key).
1103 | mov eax, 1
1104 | shl eax, cl
1105 | dec eax
1106 | and eax, TSTRING:edx->tsv.hash
1107 | Nodemul NODE:eax
1108 | add NODE:eax, TABLE:edi->node
1109 |
1110 |1: // Start of inner loop. Check node key.
1111 | cmp dword NODE:eax->i_key.nk.tt, LUA_TSTRING
1112 | jne >2
1113 | cmp aword NODE:eax->i_key.nk.value, TSTRING:edx
1114 | jne >2
1115 | // Note: swapping the two checks is faster, but valgrind complains.
1116 |// Assumes: (int)&(((Node *)0)->i_val) == (int)&(((StkId)0)->value)
1117 |
1118 |// Ok, key found. Copy node value to destination (stack) slot.
1119 | mov ecx, NODE:eax->i_val.tt
1120 | test ecx, ecx; je >3 // Node has nil value?
1121 ||if (J->flags & JIT_F_CPU_SSE2) {
1122 | movq xmm0, qword NODE:eax->i_val.value
1123 | movq qword BASE->value, xmm0
1124 ||} else {
1125 | mov edx, NODE:eax->i_val.value
1126 | mov edi, NODE:eax->i_val.value.na[1]
1127 | mov BASE->value, edx
1128 | mov BASE->value.na[1], edi
1129 ||}
1130 | mov BASE->tt, ecx
1131 | mov BASE, L->base
1132 | ret
1133 |2:
1134 | mov NODE:eax, NODE:eax->i_key.nk.next // Get next key in chain.
1135 | test NODE:eax, NODE:eax
1136 | jnz <1 // Loop if non-NULL.
1137 |
1138 | xor ecx, ecx
1139 |3:
1140 | mov TABLE:eax, TABLE:edi->metatable
1141 | test TABLE:eax, TABLE:eax
1142 | jz >4 // No metatable?
1143 | test byte TABLE:eax->flags, 1<<TM_INDEX
1144 | jz >5 // Or 'no __index' flag set?
1145 |4:
1146 | settt BASE[0], ecx // Yes, set to nil.
1147 | mov BASE, L->base
1148 | ret
1149 |
1150 |5: // Otherwise chain to C code which eventually calls luaV_gettable.
1151 | setsvalue L->env, TSTRING:edx // Use L->env as temp key.
1152 | mov ecx, [esp]
1153 | sub esp, FRAME_OFFSET
1154 | mov L->savedpc, ecx
1155 | call &jit_gettable_fb, L, TABLE:edi, BASE
1156 | add esp, FRAME_OFFSET
1157 | mov BASE, L->base
1158 | ret
1159 |.endjsub
1160 |
1161 |//-----------------------------------------------------------------------
1162 |.jsub GETTABLE_STR // Lookup string in table.
1163 |// Call with: TOP (tab), TVALUE:ecx (key), BASE (dest)
1164 | mov eax, TOP->tt; shl eax, 4; or eax, TVALUE:ecx->tt
1165 | cmp eax, LUA_TTABLE_STR
1166 | mov TABLE:edi, TOP->value
1167 | mov TSTRING:edx, TVALUE:ecx->value
1168 | je <9 // Types ok? Continue above.
1169 | jmp ->DEOPTIMIZE_CALLER // Otherwise deoptimize.
1170 |.endjsub
1171}
1172
1173/* Fallback for SETTABLE_*STR. Temporary (string) key is in L->env. */
1174static void jit_settable_fb(lua_State *L, Table *t, StkId val)
1175{
1176 Table *mt = t->metatable;
1177 const TValue *tm = luaH_getstr(mt, G(L)->tmname[TM_NEWINDEX]);
1178 if (ttisnil(tm)) { /* No __newindex method? */
1179 mt->flags |= 1<<TM_NEWINDEX; /* Cache this fact. */
1180 t->flags = 0; /* But need to clear the cache for the table itself. */
1181 setobj2t(L, luaH_setstr(L, t, rawtsvalue(&L->env)), val);
1182 luaC_barriert(L, t, val);
1183 } else if (ttisfunction(tm)) { /* __newindex function? */
1184 setobj2s(L, L->top, tm);
1185 sethvalue(L, L->top+1, t);
1186 setobj2s(L, L->top+2, &L->env);
1187 setobj2s(L, L->top+3, val);
1188 luaD_checkstack(L, 4);
1189 L->top += 4;
1190 luaD_call(L, L->top - 4, 0);
1191 } else { /* Let luaV_settable() continue with the __newindex object. */
1192 luaV_settable(L, tm, &L->env, val);
1193 }
1194
1195 |//-----------------------------------------------------------------------
1196 |.jsub BARRIERBACK // luaC_barrierback() with regparms.
1197 |// Call with: TABLE:edi (table). Destroys ecx, edx.
1198 | mov GL:ecx, L->l_G
1199 | and byte TABLE:edi->marked, (~bitmask(BLACKBIT))&0xff
1200 | mov edx, GL:ecx->grayagain
1201 | mov GL:ecx->grayagain, TABLE:edi
1202 | mov TABLE:edi->gclist, edx
1203 | ret
1204 |.endjsub
1205 |
1206 |//-----------------------------------------------------------------------
1207 |.jsub SETGLOBAL // Set global variable.
1208 |// Call with: TSTRING:edx (key), BASE (val)
1209 | mov CI, L->ci
1210 | mov TOP, CI->func
1211 | mov LCL, TOP->value
1212 | mov TABLE:edi, LCL->env
1213 | jmp >9
1214 |.endjsub
1215 |
1216 |//-----------------------------------------------------------------------
1217 |.jsub SETTABLE_KSTR // Set constant string entry in table.
1218 |// Call with: TOP (tab), TSTRING:edx (key), BASE (val)
1219 | cmp dword TOP->tt, LUA_TTABLE
1220 | mov TABLE:edi, TOP->value
1221 | jne ->DEOPTIMIZE_CALLER // Not a table? Deoptimize.
1222 |
1223 |// Common entry: TABLE:edi (tab), TSTRING:edx (key), BASE (val)
1224 |// Restores BASE, destroys eax, ecx, edx, edi (TOP).
1225 |9:
1226 | movzx ecx, byte TABLE:edi->lsizenode // hashstr(t, key).
1227 | mov eax, 1
1228 | shl eax, cl
1229 | dec eax
1230 | and eax, TSTRING:edx->tsv.hash
1231 | Nodemul NODE:eax
1232 | add NODE:eax, TABLE:edi->node
1233 |
1234 |1: // Start of inner loop. Check node key.
1235 | cmp dword NODE:eax->i_key.nk.tt, LUA_TSTRING
1236 | jne >4
1237 | cmp aword NODE:eax->i_key.nk.value, TSTRING:edx
1238 | jne >4
1239 | // Note: swapping the two checks is faster, but valgrind complains.
1240 |
1241 |// Ok, key found. Copy new value to node value.
1242 | cmp dword NODE:eax->i_val.tt, LUA_TNIL // Previous value is nil?
1243 | je >6
1244 | // Assumes: (int)&(((Node *)0)->i_val) == (int)&(((StkId)0)->value)
1245 |2:
1246 | mov byte TABLE:edi->flags, 0 // Clear metamethod cache.
1247 |3: // Target for SETTABLE_NUM below.
1248 | test byte TABLE:edi->marked, bitmask(BLACKBIT) // isblack(table)
1249 | jnz >8 // Unlikely, but set barrier back.
1250 |7: // Caveat: recycled label.
1251 | copyslot TVALUE:eax[0], BASE[0], ecx, edx, TOP
1252 | mov BASE, L->base
1253 | ret
1254 |
1255 |8: // Avoid valiswhite() check -- black2gray(table) is ok.
1256 | call ->BARRIERBACK
1257 | jmp <7
1258 |
1259 |4:
1260 | mov NODE:eax, NODE:eax->i_key.nk.next // Get next key in chain.
1261 | test NODE:eax, NODE:eax
1262 | jnz <1 // Loop if non-NULL.
1263 |
1264 |// Key not found. Add a new one, but check metatable first.
1265 | mov TABLE:ecx, TABLE:edi->metatable
1266 | test TABLE:ecx, TABLE:ecx
1267 | jz >5 // No metatable?
1268 | test byte TABLE:ecx->flags, 1<<TM_NEWINDEX
1269 | jz >7 // Or 'no __newindex' flag set?
1270 |
1271 |5: // Add new key.
1272 | // No need for setting L->savedpc since only LUA_ERRMEM may be thrown.
1273 | lea TVALUE:eax, L->env
1274 | setsvalue TVALUE:eax[0], TSTRING:edx
1275 | sub esp, FRAME_OFFSET
1276 | call &luaH_newkey, L, TABLE:edi, TVALUE:eax
1277 | add esp, FRAME_OFFSET
1278 | jmp <2 // Copy to the returned value. See Node/TValue assumption above.
1279 |
1280 |6: // Key found, but previous value is nil.
1281 | mov TABLE:ecx, TABLE:edi->metatable
1282 | test TABLE:ecx, TABLE:ecx
1283 | jz <2 // No metatable?
1284 | test byte TABLE:ecx->flags, 1<<TM_NEWINDEX
1285 | jnz <2 // Or 'no __newindex' flag set?
1286 |
1287 |7: // Otherwise chain to C code which eventually calls luaV_settable.
1288 | setsvalue L->env, TSTRING:edx // Use L->env as temp key.
1289 | mov ecx, [esp]
1290 | sub esp, FRAME_OFFSET
1291 | mov L->savedpc, ecx
1292 | call &jit_settable_fb, L, TABLE:edi, BASE
1293 | add esp, FRAME_OFFSET
1294 | mov BASE, L->base
1295 | ret
1296 |.endjsub
1297 |
1298 |//-----------------------------------------------------------------------
1299 |.jsub SETTABLE_STR // Set string entry in table.
1300 |// Call with: TOP (tab), TVALUE:ecx (key), BASE (val)
1301 | mov eax, TOP->tt; shl eax, 4; or eax, TVALUE:ecx->tt
1302 | cmp eax, LUA_TTABLE_STR
1303 | mov TABLE:edi, TOP->value
1304 | mov TSTRING:edx, TVALUE:ecx->value
1305 | je <9 // Types ok? Continue above.
1306 | jmp ->DEOPTIMIZE_CALLER // Otherwise deoptimize.
1307 |.endjsub
1308}
1309
1310/* ------------------------------------------------------------------------ */
1311
1312static void jit_op_newtable(jit_State *J, int dest, int lnarray, int lnhash)
1313{
1314 | call &luaH_new, L, luaO_fb2int(lnarray), luaO_fb2int(lnhash)
1315 | sethvalue BASE[dest], eax
1316 jit_checkGC(J);
1317}
1318
1319static void jit_op_getglobal(jit_State *J, int dest, int kidx)
1320{
1321 const TValue *kk = &J->pt->k[kidx];
1322 jit_assert(ttisstring(kk));
1323 | mov TSTRING:edx, &&kk->value.gc->ts
1324 | addidx BASE, dest
1325 | call ->GETGLOBAL
1326}
1327
1328static void jit_op_setglobal(jit_State *J, int rval, int kidx)
1329{
1330 const TValue *kk = &J->pt->k[kidx];
1331 jit_assert(ttisstring(kk));
1332 | mov TSTRING:edx, &&kk->value.gc->ts
1333 | addidx BASE, rval
1334 | call ->SETGLOBAL
1335}
1336
1337enum { TKEY_KSTR = -2, TKEY_STR = -1, TKEY_ANY = 0 };
1338
1339/* Optimize key lookup depending on consts or hints type. */
1340static int jit_keylookup(jit_State *J, int tab, int rkey)
1341{
1342 const TValue *tabt = hint_get(J, TYPE);
1343 const TValue *key;
1344 if (!ttistable(tabt)) return TKEY_ANY; /* Not a table? Use fallback. */
1345 key = ISK(rkey) ? &J->pt->k[INDEXK(rkey)] : hint_get(J, TYPEKEY);
1346 if (ttisstring(key)) { /* String key? */
1347 if (ISK(rkey)) {
1348 | lea TOP, BASE[tab]
1349 | mov TSTRING:edx, &&key->value.gc->ts
1350 return TKEY_KSTR; /* Const string key. */
1351 } else {
1352 | lea TOP, BASE[tab]
1353 | lea TVALUE:ecx, BASE[rkey]
1354 return TKEY_STR; /* Var string key. */
1355 }
1356 } else if (ttisnumber(key)) { /* Number key? */
1357 lua_Number n = nvalue(key);
1358 int k;
1359 lua_number2int(k, n);
1360 if (!(k >= 1 && k < (1 << 26) && (lua_Number)k == n))
1361 return TKEY_ANY; /* Not a proper array key? Use fallback. */
1362 if (ISK(rkey)) {
1363 | istable tab
1364 | mov TABLE:edi, BASE[tab].value
1365 | jne >9 // TYPE hint was wrong?
1366 | mov ecx, k // Needed for hash fallback.
1367 | mov TVALUE:eax, TABLE:edi->array
1368 | cmp ecx, TABLE:edi->sizearray; ja >5 // Not in array part?
1369 return k; /* Const array key (>= 1). */
1370 } else {
1371 | mov eax, BASE[tab].tt; shl eax, 4; or eax, BASE[rkey].tt
1372 | cmp eax, LUA_TTABLE_NUM; jne >9 // TYPE/TYPEKEY hint was wrong?
1373 if (J->flags & JIT_F_CPU_SSE2) {
1374 | movsd xmm0, qword BASE[rkey]
1375 | cvttsd2si eax, xmm0
1376 | cvtsi2sd xmm1, eax
1377 | dec eax
1378 | ucomisd xmm1, xmm0
1379 | mov TABLE:edi, BASE[tab].value
1380 | jne >9; jp >9 // Not an integer? Deoptimize.
1381 } else {
1382 |// Annoying x87 stuff: check whether a number is an integer.
1383 |// The latency of fist/fild is the real problem here.
1384 | fld qword BASE[rkey].value
1385 | fist dword TMP1
1386 | fild dword TMP1
1387 | fcomparepp // eax may be modified.
1388 | jne >9; jp >9 // Not an integer? Deoptimize.
1389 | mov eax, TMP1
1390 | mov TABLE:edi, BASE[tab].value
1391 | dec eax
1392 }
1393 | cmp eax, TABLE:edi->sizearray; jae >5 // Not in array part?
1394 | TValuemul eax
1395 | add eax, TABLE:edi->array
1396 return 1; /* Variable array key. */
1397 }
1398 }
1399 return TKEY_ANY; /* Use fallback. */
1400}
1401
1402static void jit_op_gettable(jit_State *J, int dest, int tab, int rkey)
1403{
1404 int k = jit_keylookup(J, tab, rkey);
1405 switch (k) {
1406 case TKEY_KSTR: /* Const string key. */
1407 | addidx BASE, dest
1408 | call ->GETTABLE_KSTR
1409 break;
1410 case TKEY_STR: /* Variable string key. */
1411 | addidx BASE, dest
1412 | call ->GETTABLE_STR
1413 break;
1414 case TKEY_ANY: /* Generic gettable fallback. */
1415 if (ISK(rkey)) {
1416 | mov ecx, &&J->pt->k[INDEXK(rkey)]
1417 } else {
1418 | lea ecx, BASE[rkey]
1419 }
1420 | lea edx, BASE[tab]
1421 | addidx BASE, dest
1422 | mov L->savedpc, &J->nextins
1423 | call &luaV_gettable, L, edx, ecx, BASE
1424 | mov BASE, L->base
1425 break;
1426 default: /* Array key. */
1427 |// This is really copyslot BASE[dest], TVALUE:eax[k-1] mixed with compare.
1428 |1:
1429 | mov edx, TVALUE:eax[k-1].tt
1430 | test edx, edx; je >6 // Array has nil value?
1431 if (J->flags & JIT_F_CPU_SSE2) {
1432 | movq xmm0, qword TVALUE:eax[k-1].value
1433 | movq qword BASE[dest].value, xmm0
1434 } else {
1435 | mov ecx, TVALUE:eax[k-1].value
1436 | mov eax, TVALUE:eax[k-1].value.na[1]
1437 | mov BASE[dest].value, ecx
1438 | mov BASE[dest].value.na[1], eax
1439 }
1440 |2:
1441 | mov BASE[dest].tt, edx
1442 |.tail
1443 |5: // Fallback to hash part. TABLE:edi is callee-saved.
1444 if (ISK(rkey)) {
1445 | call ->GETTABLE_KNUM
1446 } else {
1447 | call ->GETTABLE_NUM
1448 }
1449 | jmp <1 // Slot is at TVALUE:eax[k-1].
1450 |
1451 |6: // Shortcut for tables without an __index metamethod.
1452 | mov TABLE:ecx, TABLE:edi->metatable
1453 | test TABLE:ecx, TABLE:ecx
1454 | jz <2 // No metatable?
1455 | test byte TABLE:ecx->flags, 1<<TM_INDEX
1456 | jnz <2 // Or 'no __index' flag set?
1457 |
1458 |9: // Otherwise deoptimize.
1459 | mov edx, &J->nextins
1460 | jmp ->DEOPTIMIZE
1461 |.code
1462 break;
1463 }
1464
1465 |.jsub GETTABLE_KNUM // Gettable fallback for const numeric keys.
1466 | mov TMP2, ecx // Save k.
1467 | sub esp, FRAME_OFFSET
1468 | call &luaH_getnum, TABLE:edi, ecx
1469 | add esp, FRAME_OFFSET
1470 | mov ecx, TMP2 // Restore k.
1471 | TValuemul ecx
1472 | sub TVALUE:eax, ecx // Compensate for TVALUE:eax[k-1].
1473 | add TVALUE:eax, #TVALUE
1474 | ret
1475 |.endjsub
1476 |
1477 |.jsub GETTABLE_NUM // Gettable fallback for variable numeric keys.
1478 | inc eax
1479 | mov ARG2, TABLE:edi // Really ARG1 and ARG2.
1480 | mov ARG3, eax
1481 | jmp &luaH_getnum // Chain to C code.
1482 |.endjsub
1483}
1484
1485static void jit_op_settable(jit_State *J, int tab, int rkey, int rval)
1486{
1487 const TValue *val = ISK(rval) ? &J->pt->k[INDEXK(rval)] : NULL;
1488 int k = jit_keylookup(J, tab, rkey);
1489 switch (k) {
1490 case TKEY_KSTR: /* Const string key. */
1491 case TKEY_STR: /* Variable string key. */
1492 if (ISK(rval)) {
1493 | mov BASE, &val
1494 } else {
1495 | addidx BASE, rval
1496 }
1497 if (k == TKEY_KSTR) {
1498 | call ->SETTABLE_KSTR
1499 } else {
1500 | call ->SETTABLE_STR
1501 }
1502 break;
1503 case TKEY_ANY: /* Generic settable fallback. */
1504 if (ISK(rkey)) {
1505 | mov ecx, &&J->pt->k[INDEXK(rkey)]
1506 } else {
1507 | lea ecx, BASE[rkey]
1508 }
1509 if (ISK(rval)) {
1510 | mov edx, &val
1511 } else {
1512 | lea edx, BASE[rval]
1513 }
1514 | addidx BASE, tab
1515 | mov L->savedpc, &J->nextins
1516 | call &luaV_settable, L, BASE, ecx, edx
1517 | mov BASE, L->base
1518 break;
1519 default: /* Array key. */
1520 |1:
1521 | tvisnil TVALUE:eax[k-1]; je >6 // Previous value is nil?
1522 |2:
1523 |.tail
1524 |5: // Fallback to hash part. TABLE:edi is callee-saved.
1525 if (ISK(rkey)) {
1526 | call ->SETTABLE_KNUM
1527 } else {
1528 | call ->SETTABLE_NUM
1529 }
1530 | jmp <1 // Slot is at TVALUE:eax[k-1].
1531 |
1532 |6: // Shortcut for tables without a __newindex metamethod.
1533 | mov TABLE:ecx, TABLE:edi->metatable
1534 | test TABLE:ecx, TABLE:ecx
1535 | jz <2 // No metatable?
1536 | test byte TABLE:ecx->flags, 1<<TM_NEWINDEX
1537 | jnz <2 // Or 'no __newindex' flag set?
1538 |
1539 |9: // Otherwise deoptimize.
1540 | mov edx, &J->nextins
1541 | jmp ->DEOPTIMIZE
1542 |.code
1543 if (!ISK(rval) || iscollectable(val)) {
1544 | test byte TABLE:edi->marked, bitmask(BLACKBIT) // isblack(table)
1545 | jnz >7 // Unlikely, but set barrier back.
1546 |3:
1547 |.tail
1548 |7: // Avoid valiswhite() check -- black2gray(table) is ok.
1549 | call ->BARRIERBACK
1550 | jmp <3
1551 |.code
1552 }
1553 if (ISK(rval)) {
1554 | copyconst TVALUE:eax[k-1], val
1555 } else {
1556 | copyslot TVALUE:eax[k-1], BASE[rval], ecx, edx, TOP
1557 }
1558 break;
1559 }
1560
1561 |.jsub SETTABLE_KNUM // Settable fallback for const numeric keys.
1562 | mov TMP2, ecx // Save k.
1563 | sub esp, FRAME_OFFSET
1564 | call &luaH_setnum, L, TABLE:edi, ecx
1565 | add esp, FRAME_OFFSET
1566 | mov ecx, TMP2 // Restore k.
1567 | TValuemul ecx
1568 | sub TVALUE:eax, ecx // Compensate for TVALUE:eax[k-1].
1569 | add TVALUE:eax, #TVALUE
1570 | ret
1571 |.endjsub
1572 |
1573 |.jsub SETTABLE_NUM // Settable fallback for variable numeric keys.
1574 | inc eax
1575 | mov ARG2, L // Really ARG1, ARG2 and ARG3.
1576 | mov ARG3, TABLE:edi
1577 | mov ARG4, eax
1578 | jmp &luaH_setnum // Chain to C code.
1579 |.endjsub
1580}
1581
1582static void jit_op_self(jit_State *J, int dest, int tab, int rkey)
1583{
1584 | copyslot BASE[dest+1], BASE[tab]
1585 jit_op_gettable(J, dest, tab, rkey);
1586}
1587
1588/* ------------------------------------------------------------------------ */
1589
1590static void jit_op_setlist(jit_State *J, int ra, int num, int batch)
1591{
1592 if (batch == 0) { batch = (int)(*J->nextins); J->combine++; }
1593 batch = (batch-1)*LFIELDS_PER_FLUSH;
1594 if (num == 0) { /* Previous op was open and set TOP: {f()} or {...}. */
1595 | mov L->env.value, TOP // Need to save TOP (edi).
1596 | lea eax, BASE[ra+1]
1597 | sub eax, TOP
1598 | neg eax
1599 | TValuediv eax // num = (TOP-ra-1)/sizeof(TValue).
1600 | mov TABLE:edi, BASE[ra].value
1601 | jz >4 // Nothing to set?
1602 if (batch > 0) {
1603 | add eax, batch
1604 }
1605 | cmp dword TABLE:edi->sizearray, eax
1606 | jae >1 // Skip resize if not needed.
1607 | // A resize is likely, so inline it.
1608 | call &luaH_resizearray, L, TABLE:edi, eax
1609 |1:
1610 | test byte TABLE:edi->marked, bitmask(BLACKBIT) // isblack(table)
1611 | mov edx, TABLE:edi->array
1612 | jnz >6 // Unlikely, but set barrier back.
1613 | mov TOP, L->env.value
1614 |
1615 |.tail
1616 |6: // Avoid lots of valiswhite() checks -- black2gray(table) is ok.
1617 | call ->BARRIERBACK
1618 | jmp <1 // Need to reload edx.
1619 |.code
1620 } else { /* Set fixed number of args. */
1621 | mov TABLE:edi, BASE[ra].value // edi is callee-save.
1622 | cmp dword TABLE:edi->sizearray, batch+num
1623 | jb >5 // Need to resize array?
1624 |1:
1625 | test byte TABLE:edi->marked, bitmask(BLACKBIT) // isblack(table)
1626 | mov edx, TABLE:edi->array
1627 | jnz >6 // Unlikely, but set barrier back.
1628 | lea TOP, BASE[ra+1+num] // Careful: TOP is edi.
1629 |
1630 |.tail
1631 |5: // A resize is unlikely (impossible?). NEWTABLE should've done it.
1632 | call &luaH_resizearray, L, TABLE:edi, batch+num
1633 | jmp <1
1634 |6: // Avoid lots of valiswhite() checks -- black2gray(table) is ok.
1635 | call ->BARRIERBACK
1636 | jmp <1 // Need to reload edx.
1637 |.code
1638 }
1639 if (batch > 0) {
1640 | add edx, batch*#TVALUE // edx = &t->array[(batch+1)-1]
1641 }
1642 | lea ecx, BASE[ra+1]
1643 |3: // Copy stack slots to array.
1644 | mov eax, [ecx]
1645 | add ecx, aword*1
1646 | mov [edx], eax
1647 | add edx, aword*1
1648 | cmp ecx, TOP
1649 | jb <3
1650 |
1651 |4:
1652 if (num == 0) { /* Previous op was open. Restore L->top. */
1653 | lea TOP, BASE[J->pt->maxstacksize] // Faster than getting L->ci->top.
1654 | mov L->top, TOP
1655 }
1656}
1657
1658/* ------------------------------------------------------------------------ */
1659
1660static void jit_op_arith(jit_State *J, int dest, int rkb, int rkc, int ev)
1661{
1662 const TValue *kkb = ISK(rkb) ? &J->pt->k[INDEXK(rkb)] : NULL;
1663 const TValue *kkc = ISK(rkc) ? &J->pt->k[INDEXK(rkc)] : NULL;
1664 const Value *kval;
1665 int idx, rev;
1666 int target = (ev == TM_LT || ev == TM_LE) ? jit_jmp_target(J) : 0;
1667 int hastail = 0;
1668
1669 /* The bytecode compiler already folds constants except for: k/0, k%0, */
1670 /* NaN results, k1<k2, k1<=k2. No point in optimizing these cases. */
1671 if (ISK(rkb&rkc)) goto fallback;
1672
1673 /* Avoid optimization when non-numeric constants are present. */
1674 if (kkb ? !ttisnumber(kkb) : (kkc && !ttisnumber(kkc))) goto fallback;
1675
1676 /* The TYPE hint selects numeric inlining and/or fallback encoding. */
1677 switch (ttype(hint_get(J, TYPE))) {
1678 case LUA_TNIL: hastail = 1; break; /* No hint: numeric + fallback. */
1679 case LUA_TNUMBER: break; /* Numbers: numeric + deoptimization. */
1680 default: goto fallback; /* Mixed/other types: fallback only. */
1681 }
1682
1683 /* The checks above ensure: at most one of the operands is a constant. */
1684 /* Reverse operation and swap operands so the 2nd operand is a variable. */
1685 if (kkc) { kval = &kkc->value; idx = rkb; rev = 1; }
1686 else { kval = kkb ? &kkb->value : NULL; idx = rkc; rev = 0; }
1687
1688 /* Special handling for some operators. */
1689 switch (ev) {
1690 case TM_MOD:
1691 /* Check for modulo with positive numbers, so we can use fprem. */
1692 if (kval) {
1693 if (kval->na[1] < 0) { hastail = 0; goto fallback; } /* x%-k, -k%x */
1694 | isnumber idx
1695 | mov eax, BASE[idx].value.na[1]
1696 | jne L_DEOPTIMIZEF
1697 | test eax, eax; js L_DEOPTIMIZEF
1698 |// This will trigger deoptimization in some benchmarks (pidigits).
1699 |// But it's still a win.
1700 if (kkb) {
1701 | fld qword BASE[rkc].value
1702 | fld qword [kval]
1703 } else {
1704 | fld qword [kval]
1705 | fld qword BASE[rkb].value
1706 }
1707 } else {
1708 | isnumber2 rkb, rkc
1709 | mov eax, BASE[rkb].value.na[1]
1710 | jne L_DEOPTIMIZEF
1711 | or eax, BASE[rkc].value.na[1]; js L_DEOPTIMIZEF
1712 | fld qword BASE[rkc].value
1713 | fld qword BASE[rkb].value
1714 }
1715 |1: ; fprem; fnstsw ax; sahf; jp <1
1716 | fstp st1
1717 goto fpstore;
1718 case TM_POW:
1719 if (hastail || !kval) break; /* Avoid this if not optimizing. */
1720 if (rev) { /* x^k for k > 0, k integer. */
1721 lua_Number n = kval->n;
1722 int k;
1723 lua_number2int(k, n);
1724 /* All positive integers would work. But need to limit code explosion. */
1725 if (k > 0 && k <= 65536 && (lua_Number)k == n) {
1726 | isnumber idx; jne L_DEOPTIMIZEF
1727 | fld qword BASE[idx]
1728 for (; (k & 1) == 0; k >>= 1) { /* Handle leading zeroes (2^k). */
1729 | fmul st0
1730 }
1731 if ((k >>= 1) != 0) { /* Handle trailing bits. */
1732 | fld st0
1733 | fmul st0
1734 for (; k != 1; k >>= 1) {
1735 if (k & 1) {
1736 | fmul st1, st0
1737 }
1738 | fmul st0
1739 }
1740 | fmulp st1
1741 }
1742 goto fpstore;
1743 }
1744 } else if (kval->n > (lua_Number)0) { /* k^x for k > 0. */
1745 int log2kval[3]; /* Enough storage for a tword (80 bits). */
1746 log2kval[2] = 0; /* Avoid leaking garbage. */
1747 /* Double precision log2(k) doesn't cut it (3^x != 3 for x = 1). */
1748 ((void (*)(int *, double))J->jsub[JSUB_LOG2_TWORD])(log2kval, kval->n);
1749 | mov ARG1, log2kval[0] // Abuse stack for tword const.
1750 | mov ARG2, log2kval[1]
1751 | mov ARG3, log2kval[2] // TODO: store2load fwd stall.
1752 | isnumber idx; jne L_DEOPTIMIZEF
1753 | fld tword [esp]
1754 | fmul qword BASE[idx].value // log2(k)*x
1755 | fld st0; frndint; fsub st1, st0; fxch // Split into fract/int part.
1756 | f2xm1; fld1; faddp st1; fscale // (2^fract-1 +1) << int.
1757 | fstp st1
1758
1759 |.jsub LOG2_TWORD // Calculate log2(k) with max. precision.
1760 |// Called with (int *ptr, double k).
1761 | fld1; fld FPARG2 // Offset ok due to retaddr.
1762 | fyl2x
1763 | mov eax, ARG2 // Really ARG1.
1764 | fstp tword [eax]
1765 | ret
1766 |.endjsub
1767 goto fpstore;
1768 }
1769 break;
1770 }
1771
1772 /* Check number type and load 1st operand. */
1773 if (kval) {
1774 | isnumber idx; jne L_DEOPTIMIZEF
1775 | loadnvaluek kval
1776 } else {
1777 if (rkb == rkc) {
1778 | isnumber rkb
1779 } else {
1780 | isnumber2 rkb, rkc
1781 }
1782 | jne L_DEOPTIMIZEF
1783 | fld qword BASE[rkb].value
1784 }
1785
1786 /* Encode arithmetic operation with 2nd operand. */
1787 switch ((ev<<1)+rev) {
1788 case TM_ADD<<1: case (TM_ADD<<1)+1:
1789 if (rkb == rkc) {
1790 | fadd st0
1791 } else {
1792 | fadd qword BASE[idx].value
1793 }
1794 break;
1795 case TM_SUB<<1:
1796 | fsub qword BASE[idx].value
1797 break;
1798 case (TM_SUB<<1)+1:
1799 | fsubr qword BASE[idx].value
1800 break;
1801 case TM_MUL<<1: case (TM_MUL<<1)+1:
1802 if (rkb == rkc) {
1803 | fmul st0
1804 } else {
1805 | fmul qword BASE[idx].value
1806 }
1807 break;
1808 case TM_DIV<<1:
1809 | fdiv qword BASE[idx].value
1810 break;
1811 case (TM_DIV<<1)+1:
1812 | fdivr qword BASE[idx].value
1813 break;
1814 case TM_POW<<1:
1815 | sub esp, S2LFRAME_OFFSET
1816 | fstp FPARG1
1817 | fld qword BASE[idx].value
1818 | fstp FPARG2
1819 | call &pow
1820 | add esp, S2LFRAME_OFFSET
1821 break;
1822 case (TM_POW<<1)+1:
1823 | sub esp, S2LFRAME_OFFSET
1824 | fstp FPARG2
1825 | fld qword BASE[idx].value
1826 | fstp FPARG1
1827 | call &pow
1828 | add esp, S2LFRAME_OFFSET
1829 break;
1830 case TM_UNM<<1: case (TM_UNM<<1)+1:
1831 | fchs // No 2nd operand.
1832 break;
1833 default: /* TM_LT or TM_LE. */
1834 | fld qword BASE[idx].value
1835 | fcomparepp
1836 | jp =>dest?(J->nextpc+1):target // Unordered means false.
1837 jit_assert(dest == 0 || dest == 1); /* Really cond. */
1838 switch (((rev^dest)<<1)+(dest^(ev == TM_LT))) {
1839 case 0:
1840 | jb =>target
1841 break;
1842 case 1:
1843 | jbe =>target
1844 break;
1845 case 2:
1846 | ja =>target
1847 break;
1848 case 3:
1849 | jae =>target
1850 break;
1851 }
1852 goto skipstore;
1853 }
1854fpstore:
1855 /* Store result and set result type (if necessary). */
1856 | fstp qword BASE[dest].value
1857 if (dest != rkb && dest != rkc) {
1858 | settt BASE[dest], LUA_TNUMBER
1859 }
1860
1861skipstore:
1862 if (!hastail) {
1863 jit_deopt_target(J, 0);
1864 return;
1865 }
1866
1867 |4:
1868 |.tail
1869 |L_DEOPTLABEL: // Recycle as fallback label.
1870
1871fallback:
1872 /* Generic fallback for arithmetic ops. */
1873 if (kkb) {
1874 | mov ecx, &kkb
1875 } else {
1876 | lea ecx, BASE[rkb]
1877 }
1878 if (kkc) {
1879 | mov edx, &kkc
1880 } else {
1881 | lea edx, BASE[rkc]
1882 }
1883 if (target) { /* TM_LT or TM_LE. */
1884 | mov L->savedpc, &(J->nextins+1)
1885 | call &ev==TM_LT?luaV_lessthan:luaV_lessequal, L, ecx, edx
1886 | test eax, eax
1887 | mov BASE, L->base
1888 if (dest) { /* cond */
1889 | jnz =>target
1890 } else {
1891 | jz =>target
1892 }
1893 } else {
1894 | addidx BASE, dest
1895 | mov L->savedpc, &J->nextins
1896 | call &luaV_arith, L, BASE, ecx, edx, ev
1897 | mov BASE, L->base
1898 }
1899
1900 if (hastail) {
1901 | jmp <4
1902 |.code
1903 }
1904}
1905
1906/* ------------------------------------------------------------------------ */
1907
1908static void jit_fallback_len(lua_State *L, StkId ra, const TValue *rb)
1909{
1910 switch (ttype(rb)) {
1911 case LUA_TTABLE:
1912 setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
1913 break;
1914 case LUA_TSTRING:
1915 setnvalue(ra, cast_num(tsvalue(rb)->len));
1916 break;
1917 default: {
1918 const TValue *tm = luaT_gettmbyobj(L, rb, TM_LEN);
1919 if (ttisfunction(tm)) {
1920 ptrdiff_t rasave = savestack(L, ra);
1921 setobj2s(L, L->top, tm);
1922 setobj2s(L, L->top+1, rb);
1923 luaD_checkstack(L, 2);
1924 L->top += 2;
1925 luaD_call(L, L->top - 2, 1);
1926 ra = restorestack(L, rasave);
1927 L->top--;
1928 setobjs2s(L, ra, L->top);
1929 } else {
1930 luaG_typeerror(L, rb, "get length of");
1931 }
1932 break;
1933 }
1934 }
1935}
1936
1937static void jit_op_len(jit_State *J, int dest, int rb)
1938{
1939 switch (ttype(hint_get(J, TYPE))) {
1940 case LUA_TTABLE:
1941 jit_deopt_target(J, 0);
1942 | istable rb
1943 | mov TABLE:ecx, BASE[rb].value
1944 | jne L_DEOPTIMIZE // TYPE hint was wrong?
1945 | call &luaH_getn, TABLE:ecx
1946 | mov TMP1, eax
1947 | fild dword TMP1
1948 | fstp qword BASE[dest].value
1949 | settt BASE[dest], LUA_TNUMBER
1950 break;
1951 case LUA_TSTRING:
1952 jit_deopt_target(J, 0);
1953 | isstring rb
1954 | mov TSTRING:ecx, BASE[rb].value
1955 | jne L_DEOPTIMIZE // TYPE hint was wrong?
1956 | fild aword TSTRING:ecx->tsv.len // size_t
1957 | fstp qword BASE[dest].value
1958 | settt BASE[dest], LUA_TNUMBER
1959 break;
1960 default:
1961 | lea TVALUE:ecx, BASE[rb]
1962 | addidx BASE, dest
1963 | mov L->savedpc, &J->nextins
1964 | call &jit_fallback_len, L, BASE, TVALUE:ecx
1965 | mov BASE, L->base
1966 break;
1967 }
1968}
1969
1970static void jit_op_not(jit_State *J, int dest, int rb)
1971{
1972 /* l_isfalse() without a branch -- truly devious. */
1973 /* ((value & tt) | (tt>>1)) is only zero for nil/false. */
1974 /* Assumes: LUA_TNIL == 0, LUA_TBOOLEAN == 1, bvalue() == 0/1 */
1975 | mov eax, BASE[rb].tt
1976 | mov ecx, BASE[rb].value
1977 | mov edx, 1
1978 | and ecx, eax
1979 | shr eax, 1
1980 | or ecx, eax
1981 | xor eax, eax
1982 | cmp ecx, edx
1983 | adc eax, eax
1984 | mov BASE[dest].tt, edx
1985 | mov BASE[dest].value, eax
1986}
1987
1988/* ------------------------------------------------------------------------ */
1989
1990static void jit_op_concat(jit_State *J, int dest, int first, int last)
1991{
1992 int num = last-first+1;
1993 if (num == 2 && ttisstring(hint_get(J, TYPE))) { /* Optimize common case. */
1994 | addidx BASE, first
1995 | call ->CONCAT_STR2
1996 | setsvalue BASE[dest], eax
1997 } else { /* Generic fallback. */
1998 | mov L->savedpc, &J->nextins
1999 | call &luaV_concat, L, num, last
2000 | mov BASE, L->base
2001 if (dest != first) {
2002 | copyslot BASE[dest], BASE[first]
2003 }
2004 }
2005 jit_checkGC(J); /* Always do this, even for the optimized variant. */
2006
2007 |.jsub CONCAT_STR2 // Concatenate two strings.
2008 |// Call with: BASE (first). Destroys all regs. L and BASE restored.
2009 | mov ARG2, L // Save L (esi).
2010 | mov eax, BASE[0].tt; shl eax, 4; or eax, BASE[1].tt
2011 | sub eax, LUA_TSTR_STR // eax = 0 on success.
2012 | jne ->DEOPTIMIZE_CALLER // Wrong types? Deoptimize.
2013 |
2014 |1:
2015 | mov GL:edi, L->l_G
2016 | mov TSTRING:esi, BASE[0].value // Caveat: L (esi) is gone now!
2017 | mov TSTRING:edx, BASE[1].value
2018 | mov ecx, TSTRING:esi->tsv.len // size_t
2019 | test ecx, ecx
2020 | jz >2 // 1st string is empty?
2021 | or eax, TSTRING:edx->tsv.len // eax is known to be zero.
2022 | jz >4 // 2nd string is empty?
2023 | add eax, ecx
2024 | jc >9 // Length overflow?
2025 | cmp eax, GL:edi->buff.buffsize // size_t
2026 | ja >5 // Temp buffer overflow?
2027 | mov edi, GL:edi->buff.buffer
2028 | add esi, #TSTRING
2029 | rep; movsb // Copy first string.
2030 | mov ecx, TSTRING:edx->tsv.len
2031 | lea esi, TSTRING:edx[1]
2032 | rep; movsb // Copy second string.
2033 |
2034 | sub edi, eax // start = end - total.
2035 | mov L, ARG2 // Restore L (esi). Reuse as 1st arg.
2036 | mov ARG3, edi
2037 | mov ARG4, eax
2038 | mov BASE, L->base // Restore BASE.
2039 | jmp &luaS_newlstr
2040 |
2041 |2: // 1st string is empty.
2042 | mov eax, TSTRING:edx // Return 2nd string.
2043 |3:
2044 | mov L, ARG2 // Restore L (esi) and BASE.
2045 | mov BASE, L->base
2046 | ret
2047 |
2048 |4: // 2nd string is empty.
2049 | mov eax, TSTRING:esi // Return 1st string.
2050 | jmp <3
2051 |
2052 |5: // Resize temp buffer.
2053 | // No need for setting L->savedpc since only LUA_ERRMEM may be thrown.
2054 | mov L, ARG2 // Restore L.
2055 | lea ecx, GL:edi->buff
2056 | sub esp, FRAME_OFFSET
2057 | call &luaZ_openspace, L, ecx, eax
2058 | add esp, FRAME_OFFSET
2059 | xor eax, eax // BASE (first) and L saved. eax = 0.
2060 | jmp <1 // Just restart.
2061 |
2062 |9: // Length overflow errors are rare (> 2 GB string required).
2063 | mov L, ARG2 // Need L for deoptimization.
2064 | jmp ->DEOPTIMIZE_CALLER
2065 |.endjsub
2066}
2067
2068/* ------------------------------------------------------------------------ */
2069
2070static void jit_op_eq(jit_State *J, int cond, int rkb, int rkc)
2071{
2072 int target = jit_jmp_target(J);
2073 int condtarget = cond ? (J->nextpc+1) : target;
2074 jit_assert(cond == 0 || cond == 1);
2075
2076 /* Comparison of two constants. Evaluate at compile time. */
2077 if (ISK(rkb&rkc)) {
2078 if ((rkb == rkc) == cond) { /* Constants are already unique. */
2079 | jmp =>target
2080 }
2081 return;
2082 }
2083
2084 if (ISK(rkb|rkc)) { /* Compare a variable and a constant. */
2085 const TValue *kk;
2086 if (ISK(rkb)) { int t = rkc; rkc = rkb; rkb = t; } /* rkc holds const. */
2087 kk = &J->pt->k[INDEXK(rkc)];
2088 switch (ttype(kk)) {
2089 case LUA_TNIL:
2090 | isnil rkb
2091 break;
2092 case LUA_TBOOLEAN:
2093 if (bvalue(kk)) {
2094 | mov eax, BASE[rkb].tt
2095 | mov ecx, BASE[rkb].value
2096 | dec eax
2097 | dec ecx
2098 | or eax, ecx
2099 } else {
2100 | mov eax, BASE[rkb].tt
2101 | dec eax
2102 | or eax, BASE[rkb].value
2103 }
2104 break;
2105 case LUA_TNUMBER:
2106 |// Note: bitwise comparison is not faster (and needs to handle -0 == 0).
2107 | isnumber rkb
2108 | jne =>condtarget
2109 | fld qword BASE[rkb].value
2110 | fld qword [&kk->value]
2111 | fcomparepp
2112 | jp =>condtarget // Unordered means not equal.
2113 break;
2114 case LUA_TSTRING:
2115 | isstring rkb
2116 | jne =>condtarget
2117 | cmp aword BASE[rkb].value, &rawtsvalue(kk)
2118 break;
2119 default: jit_assert(0); break;
2120 }
2121 } else { /* Compare two variables. */
2122 | mov eax, BASE[rkb].tt
2123 | cmp eax, BASE[rkc].tt
2124 | jne =>condtarget
2125 switch (ttype(hint_get(J, TYPE))) {
2126 case LUA_TNUMBER:
2127 jit_deopt_target(J, 0);
2128 |// Note: bitwise comparison is not an option (-0 == 0, NaN ~= NaN).
2129 | cmp eax, LUA_TNUMBER; jne L_DEOPTIMIZE
2130 | fld qword BASE[rkb].value
2131 | fld qword BASE[rkc].value
2132 | fcomparepp
2133 | jp =>condtarget // Unordered means not equal.
2134 break;
2135 case LUA_TSTRING:
2136 jit_deopt_target(J, 0);
2137 | cmp eax, LUA_TSTRING; jne L_DEOPTIMIZE
2138 | mov ecx, BASE[rkb].value
2139 | cmp ecx, BASE[rkc].value
2140 break;
2141 default:
2142 |// Generic equality comparison fallback.
2143 | lea edx, BASE[rkc]
2144 | lea ecx, BASE[rkb]
2145 | mov L->savedpc, &J->nextins
2146 | call &luaV_equalval, L, ecx, edx
2147 | dec eax
2148 | mov BASE, L->base
2149 break;
2150 }
2151 }
2152 if (cond) {
2153 | je =>target
2154 } else {
2155 | jne =>target
2156 }
2157}
2158
2159/* ------------------------------------------------------------------------ */
2160
2161static void jit_op_test(jit_State *J, int cond, int dest, int src)
2162{
2163 int target = jit_jmp_target(J);
2164
2165 /* l_isfalse() without a branch. But this time preserve tt/value. */
2166 /* (((value & tt) * 2 + tt) >> 1) is only zero for nil/false. */
2167 /* Assumes: 3*tt < 2^32, LUA_TNIL == 0, LUA_TBOOLEAN == 1, bvalue() == 0/1 */
2168 | mov eax, BASE[src].tt
2169 | mov ecx, BASE[src].value
2170 | mov edx, eax
2171 | and edx, ecx
2172 | lea edx, [eax+edx*2]
2173 | shr edx, 1
2174
2175 /* Check if we can omit the stack copy. */
2176 if (dest == src) { /* Yes, invert branch condition. */
2177 if (cond) {
2178 | jnz =>target
2179 } else {
2180 | jz =>target
2181 }
2182 } else { /* No, jump around copy code. */
2183 if (cond) {
2184 | jz >1
2185 } else {
2186 | jnz >1
2187 }
2188 | mov edx, BASE[src].value.na[1]
2189 | mov BASE[dest].tt, eax
2190 | mov BASE[dest].value, ecx
2191 | mov BASE[dest].value.na[1], edx
2192 | jmp =>target
2193 |1:
2194 }
2195}
2196
2197static void jit_op_jmp(jit_State *J, int target)
2198{
2199 | jmp =>target
2200}
2201
2202/* ------------------------------------------------------------------------ */
2203
2204enum { FOR_IDX, FOR_LIM, FOR_STP, FOR_EXT };
2205
2206static const char *const jit_for_coerce_error[] = {
2207 LUA_QL("for") " initial value must be a number",
2208 LUA_QL("for") " limit must be a number",
2209 LUA_QL("for") " step must be a number",
2210};
2211
2212/* Try to coerce for slots with strings to numbers in place or complain. */
2213static void jit_for_coerce(lua_State *L, TValue *o)
2214{
2215 int i;
2216 for (i = FOR_IDX; i <= FOR_STP; i++, o++) {
2217 lua_Number num;
2218 if (ttisnumber(o)) continue;
2219 if (ttisstring(o) && luaO_str2d(svalue(o), &num)) {
2220 setnvalue(o, num);
2221 } else {
2222 luaG_runerror(L, jit_for_coerce_error[i]);
2223 }
2224 }
2225}
2226
2227static void jit_op_forprep(jit_State *J, int ra, int target)
2228{
2229 const TValue *step = hint_get(J, FOR_STEP_K);
2230 if (ttisnumber(step)) {
2231 | isnumber2 ra+FOR_IDX, ra+FOR_LIM; jne L_DEOPTIMIZEF
2232 |4:
2233 | fld qword BASE[ra+FOR_LIM].value // [lim]
2234 | fld qword BASE[ra+FOR_IDX].value // [idx lim]
2235 | fst qword BASE[ra+FOR_EXT].value // extidx = idx
2236 | fcomparepp // idx >< lim ?
2237 | settt BASE[ra+FOR_EXT], LUA_TNUMBER
2238 if (nvalue(step) < (lua_Number)0) {
2239 | jb =>target+1 // step < 0 && idx < lim: skip loop.
2240 } else {
2241 | ja =>target+1 // step >= 0 && idx > lim: skip loop.
2242 }
2243 } else {
2244 |4:
2245 | isnumber3 ra+FOR_IDX, ra+FOR_LIM, ra+FOR_STP
2246 | mov eax, BASE[ra+FOR_STP].value.na[1] // Sign bit is in hi dword.
2247 | jne L_DEOPTIMIZEF
2248 | fld qword BASE[ra+FOR_LIM].value // [lim] (FP stack notation)
2249 | fld qword BASE[ra+FOR_IDX].value // [idx lim]
2250 | test eax, eax // step >< 0 ?
2251 | fst qword BASE[ra+FOR_EXT].value // extidx = idx
2252 | js >1
2253 | fxch // if (step > 0) [lim idx]
2254 |1:
2255 | fcomparepp // step > 0 ? lim < idx : idx < lim
2256 | settt BASE[ra+FOR_EXT], LUA_TNUMBER
2257 | jb =>target+1 // Skip loop.
2258 }
2259 if (ttisnumber(hint_get(J, TYPE))) {
2260 jit_deopt_target(J, 0);
2261 } else {
2262 |.tail
2263 |L_DEOPTLABEL: // Recycle as fallback label.
2264 | // Fallback for strings as loop vars. No need to make this fast.
2265 | lea eax, BASE[ra]
2266 | mov L->savedpc, &J->nextins
2267 | call &jit_for_coerce, L, eax // Coerce strings or throw error.
2268 | jmp <4 // Easier than reloading eax.
2269 |.code
2270 }
2271}
2272
2273static void jit_op_forloop(jit_State *J, int ra, int target)
2274{
2275 const TValue *step = hint_getpc(J, FOR_STEP_K, target-1);
2276 if (ttisnumber(step)) {
2277 | fld qword BASE[ra+FOR_LIM].value // [lim] (FP stack notation)
2278 | fld qword BASE[ra+FOR_IDX].value // [idx lim]
2279 | fadd qword BASE[ra+FOR_STP].value // [nidx lim]
2280 | fst qword BASE[ra+FOR_EXT].value // extidx = nidx
2281 | fst qword BASE[ra+FOR_IDX].value // idx = nidx
2282 | settt BASE[ra+FOR_EXT], LUA_TNUMBER
2283 | fcomparepp // nidx >< lim ?
2284 if (nvalue(step) < (lua_Number)0) {
2285 | jae =>target // step < 0 && nidx >= lim: loop again.
2286 } else {
2287 | jbe =>target // step >= 0 && nidx <= lim: loop again.
2288 }
2289 } else {
2290 | mov eax, BASE[ra+FOR_STP].value.na[1] // Sign bit is in hi dword.
2291 | fld qword BASE[ra+FOR_LIM].value // [lim] (FP stack notation)
2292 | fld qword BASE[ra+FOR_IDX].value // [idx lim]
2293 | fld qword BASE[ra+FOR_STP].value // [stp idx lim]
2294 | faddp st1 // [nidx lim]
2295 | fst qword BASE[ra+FOR_IDX].value // idx = nidx
2296 | fst qword BASE[ra+FOR_EXT].value // extidx = nidx
2297 | settt BASE[ra+FOR_EXT], LUA_TNUMBER
2298 | test eax, eax // step >< 0 ?
2299 | js >1
2300 | fxch // if (step > 0) [lim nidx]
2301 |1:
2302 | fcomparepp // step > 0 ? lim >= nidx : nidx >= lim
2303 | jae =>target // Loop again.
2304 }
2305}
2306
2307/* ------------------------------------------------------------------------ */
2308
2309static void jit_op_tforloop(jit_State *J, int ra, int nresults)
2310{
2311 int target = jit_jmp_target(J);
2312 int i;
2313 if (jit_inline_tforloop(J, ra, nresults, target)) return; /* Inlined? */
2314 for (i = 2; i >= 0; i--) {
2315 | copyslot BASE[ra+i+3], BASE[ra+i] // Copy ctlvar/state/callable.
2316 }
2317 jit_op_call(J, ra+3, 2, nresults);
2318 | isnil ra+3; je >1
2319 | copyslot BASE[ra+2], BASE[ra+3] // Save control variable.
2320 | jmp =>target
2321 |1:
2322}
2323
2324/* ------------------------------------------------------------------------ */
2325
2326static void jit_op_close(jit_State *J, int ra)
2327{
2328 if (ra) {
2329 | lea eax, BASE[ra]
2330 | mov ARG2, eax
2331 } else {
2332 | mov ARG2, BASE
2333 }
2334 | call &luaF_close, L // , StkId level (ARG2)
2335}
2336
2337static void jit_op_closure(jit_State *J, int dest, int ptidx)
2338{
2339 Proto *npt = J->pt->p[ptidx];
2340 int nup = npt->nups;
2341 | getLCL edi // LCL:edi is callee-saved.
2342 | mov edx, LCL:edi->env
2343 | call &luaF_newLclosure, L, nup, edx
2344 | mov LCL->p, &npt // Store new proto in returned closure.
2345 | mov aword BASE[dest].value, LCL // setclvalue()
2346 | settt BASE[dest], LUA_TFUNCTION
2347 /* Process pseudo-instructions for upvalues. */
2348 if (nup > 0) {
2349 const Instruction *uvcode = J->nextins;
2350 int i, uvuv;
2351 /* Check which of the two types we need. */
2352 for (i = 0, uvuv = 0; i < nup; i++)
2353 if (GET_OPCODE(uvcode[i]) == OP_GETUPVAL) uvuv++;
2354 /* Copy upvalues from parent first. */
2355 if (uvuv) {
2356 /* LCL:eax->upvals (new closure) <-- LCL:edi->upvals (own closure). */
2357 for (i = 0; i < nup; i++)
2358 if (GET_OPCODE(uvcode[i]) == OP_GETUPVAL) {
2359 | mov UPVAL:edx, LCL:edi->upvals[GETARG_B(uvcode[i])]
2360 | mov LCL->upvals[i], UPVAL:edx
2361 }
2362 }
2363 /* Next find or create upvalues for our own stack slots. */
2364 if (nup > uvuv) {
2365 | mov LCL:edi, LCL // Move new closure to callee-save register. */
2366 /* LCL:edi->upvals (new closure) <-- upvalue for stack slot. */
2367 for (i = 0; i < nup; i++)
2368 if (GET_OPCODE(uvcode[i]) == OP_MOVE) {
2369 int rb = GETARG_B(uvcode[i]);
2370 if (rb) {
2371 | lea eax, BASE[rb]
2372 | mov ARG2, eax
2373 } else {
2374 | mov ARG2, BASE
2375 }
2376 | call &luaF_findupval, L // , StkId level (ARG2)
2377 | mov LCL:edi->upvals[i], UPVAL:eax
2378 }
2379 }
2380 J->combine += nup; /* Skip pseudo-instructions. */
2381 }
2382 jit_checkGC(J);
2383}
2384
2385/* ------------------------------------------------------------------------ */
2386
2387static void jit_op_vararg(jit_State *J, int dest, int num)
2388{
2389 if (num < 0) { /* Copy all varargs. */
2390 |// Copy [ci->func+1+pt->numparams, BASE) -> [BASE+dest, *).
2391 |1:
2392 | mov CI, L->ci
2393 | mov edx, CI->func
2394 | add edx, (1+J->pt->numparams)*#TVALUE // Start of varargs.
2395 |
2396 | // luaD_checkstack(L, nvararg) with nvararg = L->base - vastart.
2397 | // This is a slight overallocation (BASE[dest+nvararg] would be enough).
2398 | // We duplicate OP_VARARG behaviour so we can use luaD_growstack().
2399 | lea eax, [BASE+BASE+J->pt->maxstacksize*#TVALUE] // L->base + L->top
2400 | sub eax, edx // L->top + (L->base - vastart)
2401 | cmp eax, L->stack_last
2402 | jae >5 // Need to grow stack?
2403 |
2404 | lea TOP, BASE[dest]
2405 | cmp edx, BASE
2406 | jnb >3
2407 |2: // Copy loop.
2408 | mov eax, [edx]
2409 | add edx, aword*1
2410 | mov [TOP], eax
2411 | add TOP, aword*1
2412 | cmp edx, BASE
2413 | jb <2
2414 |3:
2415 |// This is an open ins. Must keep TOP for next instruction.
2416 |
2417 |.tail
2418 |5: // Grow stack for varargs.
2419 | sub eax, L->top
2420 | TValuediv eax
2421 | call &luaD_growstack, L, eax
2422 | mov BASE, L->base
2423 | jmp <1 // Just restart op to avoid saving/restoring regs.
2424 |.code
2425 } else if (num > 0) { /* Copy limited number of varargs. */
2426 |// Copy [ci->func+1+pt->numparams, BASE) -> [BASE+dest, BASE+dest+num).
2427 | mov CI, L->ci
2428 | mov edx, CI->func
2429 | add edx, (1+J->pt->numparams)*#TVALUE
2430 | lea TOP, BASE[dest]
2431 | lea ecx, BASE[dest+num]
2432 | cmp edx, BASE // No varargs present: only fill.
2433 | jnb >2
2434 |
2435 |1: // Copy loop.
2436 | mov eax, [edx]
2437 | add edx, aword*1
2438 | mov [TOP], eax
2439 | add TOP, aword*1
2440 | cmp TOP, ecx // Stop if all dest slots got a vararg.
2441 | jnb >4
2442 | cmp edx, BASE // Continue if more varargs present.
2443 | jb <1
2444 |
2445 |2: // Fill remaining slots with nils.
2446 | xor eax, eax // Assumes: LUA_TNIL == 0
2447 |3: // Fill loop.
2448 | settt TOP[0], eax
2449 | add TOP, #TVALUE
2450 | cmp TOP, ecx
2451 | jb <3
2452 |4:
2453 }
2454}
2455
2456/* ------------------------------------------------------------------------ */
2457
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_x86.dash b/libraries/LuaJIT-1.1.7/src/ljit_x86.dash
new file mode 100644
index 0000000..432e1c8
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_x86.dash
@@ -0,0 +1,297 @@
1|//
2|// Common DynASM definitions and macros for x86 CPUs.
3|// Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
4|//
5|
6|// Standard DynASM declarations.
7|.arch x86
8|.section code, deopt, tail, mfmap
9|
10|// Type definitions with (almost) global validity.
11|.type L, lua_State, esi // L.
12|.type BASE, TValue, ebx // L->base.
13|.type TOP, TValue, edi // L->top (calls/open ops).
14|.type CI, CallInfo, ecx // L->ci (calls, locally).
15|.type LCL, LClosure, eax // func->value (calls).
16|
17|// Type definitions with local validity.
18|.type GL, global_State
19|.type TVALUE, TValue
20|.type VALUE, Value
21|.type CINFO, CallInfo
22|.type GCOBJECT, GCObject
23|.type TSTRING, TString
24|.type TABLE, Table
25|.type CCLOSURE, CClosure
26|.type PROTO, Proto
27|.type UPVAL, UpVal
28|.type NODE, Node
29|
30|// Definitions copied to DynASM domain to avoid unnecessary constant args.
31|// CHECK: must match with the definitions in lua.h!
32|.define LUA_TNIL, 0
33|.define LUA_TBOOLEAN, 1
34|.define LUA_TLIGHTUSERDATA, 2
35|.define LUA_TNUMBER, 3
36|.define LUA_TSTRING, 4
37|.define LUA_TTABLE, 5
38|.define LUA_TFUNCTION, 6
39|.define LUA_TUSERDATA, 7
40|.define LUA_TTHREAD, 8
41|
42|.define LUA_TNUM_NUM, 0x33
43|.define LUA_TNUM_NUM_NUM, 0x333
44|.define LUA_TSTR_STR, 0x44
45|.define LUA_TSTR_NUM, 0x43
46|.define LUA_TSTR_NUM_NUM, 0x433
47|.define LUA_TTABLE_NUM, 0x53
48|.define LUA_TTABLE_STR, 0x54
49|
50|// Macros to test, set and copy stack slots.
51|.macro istt, idx, tp; cmp dword BASE[idx].tt, tp; .endmacro
52|.macro isnil, idx; istt idx, LUA_TNIL; .endmacro
53|.macro isnumber, idx; istt idx, LUA_TNUMBER; .endmacro
54|.macro isstring, idx; istt idx, LUA_TSTRING; .endmacro
55|.macro istable, idx; istt idx, LUA_TTABLE; .endmacro
56|.macro isfunction, idx; istt idx, LUA_TFUNCTION; .endmacro
57|
58|.macro isnumber2, idx1, idx2, reg
59| mov reg, BASE[idx1].tt; shl reg, 4; or reg, BASE[idx2].tt
60| cmp reg, LUA_TNUM_NUM
61|.endmacro
62|.macro isnumber2, idx1, idx2; isnumber2, idx1, idx2, eax; .endmacro
63|
64|.macro isnumber3, idx1, idx2, idx3, reg
65| mov reg, BASE[idx1].tt; shl reg, 4; or reg, BASE[idx2].tt
66| shl reg, 4; or reg, BASE[idx3].tt; cmp reg, LUA_TNUM_NUM_NUM
67|.endmacro
68|.macro isnumber3, idx1, idx2, idx3; isnumber3, idx1, idx2, idx3, eax; .endmacro
69|
70|.macro tvisnil, tv; cmp dword tv.tt, LUA_TNIL; .endmacro
71|
72|.macro settt, tv, tp; mov dword tv.tt, tp; .endmacro
73|.macro setnilvalue, tv; settt tv, LUA_TNIL; .endmacro
74|
75|.macro setbvalue, tv, val // May use edx.
76||if (val) { /* true */
77| mov edx, LUA_TBOOLEAN
78| mov dword tv.value, edx // Assumes: LUA_TBOOLEAN == 1
79| settt tv, edx
80||} else { /* false */
81| mov dword tv.value, 0
82| settt tv, LUA_TBOOLEAN
83||}
84|.endmacro
85|
86|.macro loadnvaluek, vptr
87||if ((vptr)->n == (lua_Number)0) {
88| fldz
89||} else if ((vptr)->n == (lua_Number)1) {
90| fld1
91||} else {
92| fld qword [vptr]
93||}
94|.endmacro
95|
96|.macro setnvaluek, tv, vptr // Pass a Value *! With permanent addr.
97| // SSE2 does not pay off here (I tried).
98| loadnvaluek vptr
99| fstp qword tv.value
100| settt tv, LUA_TNUMBER
101|.endmacro
102|
103|.macro setnvalue, tv, vptr // Pass a Value *! Temporary ok.
104| mov dword tv.value, (vptr)->na[0]
105| mov dword tv.value.na[1], (vptr)->na[1]
106| settt tv, LUA_TNUMBER
107|.endmacro
108|
109|.macro setsvalue, tv, vptr
110| mov aword tv.value, vptr
111| settt tv, LUA_TSTRING
112|.endmacro
113|
114|.macro sethvalue, tv, vptr
115| mov aword tv.value, vptr
116| settt tv, LUA_TTABLE
117|.endmacro
118|
119|.macro copyslotSSE, D, S, R1 // May use xmm0.
120| mov R1, S.tt; movq xmm0, qword S.value
121| mov D.tt, R1; movq qword D.value, xmm0
122|.endmacro
123|
124|.macro copyslot, D, S, R1, R2, R3
125||if (J->flags & JIT_F_CPU_SSE2) {
126| copyslotSSE D, S, R1
127||} else {
128| mov R1, S.value; mov R2, S.value.na[1]; mov R3, S.tt
129| mov D.value, R1; mov D.value.na[1], R2; mov D.tt, R3
130||}
131|.endmacro
132|
133|.macro copyslot, D, S, R1, R2
134||if (J->flags & JIT_F_CPU_SSE2) {
135| copyslotSSE D, S, R1
136||} else {
137| mov R1, S.value; mov R2, S.value.na[1]; mov D.value, R1
138| mov R1, S.tt; mov D.value.na[1], R2; mov D.tt, R1
139||}
140|.endmacro
141|
142|.macro copyslot, D, S
143| copyslot D, S, ecx, edx, eax
144|.endmacro
145|
146|.macro copyconst, tv, tvk // May use edx.
147||switch (ttype(tvk)) {
148||case LUA_TNIL:
149| setnilvalue tv
150|| break;
151||case LUA_TBOOLEAN:
152| setbvalue tv, bvalue(tvk) // May use edx.
153|| break;
154||case LUA_TNUMBER: {
155| setnvaluek tv, &(tvk)->value
156|| break;
157||}
158||case LUA_TSTRING:
159| setsvalue tv, &gcvalue(tvk)
160|| break;
161||default: lua_assert(0); break;
162||}
163|.endmacro
164|
165|// Macros to get Lua structures.
166|.macro getLCL, reg // May use CI and TOP (edi).
167||if (!J->pt->is_vararg) {
168| mov LCL:reg, BASE[-1].value
169||} else {
170| mov CI, L->ci
171| mov TOP, CI->func
172| mov LCL:reg, TOP->value
173||}
174|.endmacro
175|.macro getLCL; getLCL eax; .endmacro
176|
177|// Macros to handle variants.
178|.macro addidx, type, idx
179||if (idx) {
180| add type, idx*#type
181||}
182|.endmacro
183|
184|.macro subidx, type, idx
185||if (idx) {
186| sub type, idx*#type
187||}
188|.endmacro
189|
190|// Annoying x87 stuff: support for two compare variants.
191|.macro fcomparepp // Compare and pop st0 >< st1.
192||if (J->flags & JIT_F_CPU_CMOV) {
193| fucomip st1
194| fpop
195||} else {
196| fucompp
197| fnstsw ax // eax modified!
198| sahf
199| // Sometimes test ah, imm8 would be faster.
200| // But all following compares need to be changed then.
201| // Don't bother since this is only compatibility stuff for old CPUs.
202||}
203|.endmacro
204|
205|// If you change LUA_TVALUE_ALIGN, be sure to change the Makefile, too:
206|// DASMFLAGS= -D TVALUE_SIZE=...
207|// Then rerun make. Or change the default below:
208|.if not TVALUE_SIZE; .define TVALUE_SIZE, 16; .endif
209|
210|.if TVALUE_SIZE == 16
211| .macro TValuemul, reg; sal reg, 4; .endmacro // *16
212| .macro TValuediv, reg; sar reg, 4; .endmacro // /16
213| .macro Nodemul, reg; sal reg, 5; .endmacro // *32
214|.elif TVALUE_SIZE == 12
215| .macro TValuemul, reg; sal reg, 2; lea reg, [reg+reg*2]; .endmacro // *12
216| .macro TValuediv, reg; sal reg, 2; imul reg, 0xaaaaaaab; .endmacro // /12
217| .macro Nodemul, reg; imul reg, 28; .endmacro // *28
218|.else
219| .fatal Unsupported TValue size `TVALUE_SIZE'.
220|.endif
221|
222|//
223|// x86 C calling conventions and stack frame layout during a JIT call:
224|//
225|// ebp+aword*4 CARG2 nresults
226|// ebp+aword*3 CARG2 func (also used as SAVER3 for L)
227|// ebp+aword*2 CARG1 L
228|// ------------------------------- call to GATE_LJ
229|// ebp+aword*1 retaddr
230|// ebp+aword*0 frameptr ebp
231|// ebp-aword*1 SAVER1 TOP edi
232|// ebp-aword*2 SAVER2 BASE ebx
233|// -------------------------------
234|// GATE_LJ retaddr
235|// esp+aword*2 ARG3
236|// esp+aword*1 ARG2
237|// esp+aword*0 ARG1 <-- esp for first JIT frame
238|// -------------------------------
239|// 1st JIT frame retaddr
240|// esp+aword*2 ARG3
241|// esp+aword*1 ARG2
242|// esp+aword*0 ARG1 <-- esp for second JIT frame
243|// -------------------------------
244|// 2nd JIT frame retaddr
245|//
246|// We could omit the fixed frame pointer (ebp) and have one more register
247|// available. But there is no pressing need (could use it for CI).
248|// And it's easier for debugging (gdb is still confused -- why?).
249|//
250|// The stack is aligned to 4 awords (16 bytes). Calls to C functions
251|// with up to 3 arguments do not need any stack pointer adjustment.
252|//
253|
254|.define CARG3, [ebp+aword*4]
255|.define CARG2, [ebp+aword*3]
256|.define CARG1, [ebp+aword*2]
257|.define SAVER1, [ebp-aword*1]
258|.define SAVER2, [ebp-aword*2]
259|.define ARG7, aword [esp+aword*6] // Requires large frame.
260|.define ARG6, aword [esp+aword*5] // Requires large frame.
261|.define ARG5, aword [esp+aword*4] // Requires large frame.
262|.define ARG4, aword [esp+aword*3] // Requires large frame.
263|.define ARG3, aword [esp+aword*2]
264|.define ARG2, aword [esp+aword*1]
265|.define ARG1, aword [esp]
266|.define FRAME_RETADDR, aword [esp+aword*3]
267|.define TMP3, [esp+aword*2]
268|.define TMP2, [esp+aword*1]
269|.define TMP1, [esp]
270|.define FPARG2, qword [esp+qword*1] // Requires large frame.
271|.define FPARG1, qword [esp]
272|.define LJFRAME_OFFSET, aword*2 // 16 byte aligned with retaddr + ebp.
273|.define FRAME_OFFSET, aword*3 // 16 byte aligned with retaddr.
274|.define LFRAME_OFFSET, aword*7 // 16 byte aligned with retaddr.
275|.define S2LFRAME_OFFSET, aword*4 // Delta to large frame.
276|
277|.macro call, target, a1
278| mov ARG1, a1; call target; .endmacro
279|.macro call, target, a1, a2
280| mov ARG1, a1; mov ARG2, a2; call target; .endmacro
281|.macro call, target, a1, a2, a3
282| mov ARG1, a1; mov ARG2, a2; mov ARG3, a3; call target; .endmacro
283|.macro call, target, a1, a2, a3, a4
284| push a4; push a3; push a2; push a1
285| call target; add esp, S2LFRAME_OFFSET; .endmacro
286|.macro call, target, a1, a2, a3, a4, a5
287| mov ARG1, a5; push a4; push a3; push a2; push a1
288| call target; add esp, S2LFRAME_OFFSET; .endmacro
289|
290|// The following macros require a large frame.
291|.macro call_LFRAME, target, a1, a2, a3, a4
292| mov ARG1, a1; mov ARG2, a2; mov ARG3, a3; mov ARG4, a4
293| call target; .endmacro
294|.macro call_LFRAME, target, a1, a2, a3, a4, a5
295| mov ARG1, a1; mov ARG2, a2; mov ARG3, a3; mov ARG4, a4; mov ARG5, a5
296| call target; .endmacro
297|
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_x86.h b/libraries/LuaJIT-1.1.7/src/ljit_x86.h
new file mode 100644
index 0000000..fc860bc
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_x86.h
@@ -0,0 +1,2301 @@
1/*
2** This file has been pre-processed with DynASM.
3** http://luajit.org/dynasm.html
4** DynASM version 1.1.4, DynASM x86 version 1.1.4
5** DO NOT EDIT! The original file is in "ljit_x86.dasc".
6*/
7
8#if DASM_VERSION != 10104
9#error "Version mismatch between DynASM and included encoding engine"
10#endif
11
12/*
13** Bytecode to machine code translation for x86 CPUs.
14** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
15*/
16
17#define DASM_SECTION_CODE 0
18#define DASM_SECTION_DEOPT 1
19#define DASM_SECTION_TAIL 2
20#define DASM_SECTION_MFMAP 3
21#define DASM_MAXSECTION 4
22#define Dt1(_V) (int)&(((lua_State *)0)_V)
23#define Dt2(_V) (int)&(((TValue *)0)_V)
24#define Dt3(_V) (int)&(((TValue *)0)_V)
25#define Dt4(_V) (int)&(((CallInfo *)0)_V)
26#define Dt5(_V) (int)&(((LClosure *)0)_V)
27#define Dt6(_V) (int)&(((global_State *)0)_V)
28#define Dt7(_V) (int)&(((TValue *)0)_V)
29#define Dt8(_V) (int)&(((Value *)0)_V)
30#define Dt9(_V) (int)&(((CallInfo *)0)_V)
31#define DtA(_V) (int)&(((GCObject *)0)_V)
32#define DtB(_V) (int)&(((TString *)0)_V)
33#define DtC(_V) (int)&(((Table *)0)_V)
34#define DtD(_V) (int)&(((CClosure *)0)_V)
35#define DtE(_V) (int)&(((Proto *)0)_V)
36#define DtF(_V) (int)&(((UpVal *)0)_V)
37#define Dt10(_V) (int)&(((Node *)0)_V)
38static const unsigned char jit_actionlist[5059] = {
39 156,90,137,209,129,252,242,0,0,32,0,82,157,156,90,49,192,57,209,15,132,245,
40 247,64,83,15,162,91,137,208,249,1,195,255,254,0,251,15,249,10,141,68,36,4,
41 195,251,15,249,11,85,137,229,131,252,236,8,137,93,252,252,139,93,12,137,117,
42 12,139,117,8,137,125,252,248,139,190,235,139,131,235,139,142,235,102,252,
43 255,134,235,252,255,144,235,139,142,235,137,190,235,139,145,235,139,69,16,
44 137,150,235,139,145,235,133,192,137,150,235,15,136,245,248,193,224,4,1,195,
45 49,201,137,158,235,249,1,137,143,235,129,199,241,57,223,15,130,245,1,249,
46 2,255,102,252,255,142,235,184,239,139,125,252,248,139,93,252,252,139,117,
47 12,137,252,236,93,195,251,15,249,12,139,144,235,129,186,235,241,15,133,245,
48 247,139,146,235,137,144,235,252,255,226,249,1,131,252,236,12,139,129,235,
49 137,142,235,137,190,235,199,68,36,8,252,255,252,255,252,255,252,255,137,134,
50 235,137,92,36,4,43,158,235,137,52,36,232,244,133,192,15,133,245,248,137,52,
51 36,199,68,36,4,1,0,0,0,232,244,249,2,131,196,12,3,158,235,255,139,190,235,
52 195,251,15,249,13,141,135,235,131,252,236,12,59,134,235,15,131,245,14,59,
53 142,235,141,137,235,15,132,245,15,137,142,235,137,153,235,137,129,235,139,
54 147,235,129,195,241,137,190,235,137,158,235,137,153,235,249,16,137,52,36,
55 252,255,146,235,249,2,131,196,12,139,142,235,255,193,224,4,139,185,235,15,
56 132,245,250,139,158,235,137,218,41,195,249,3,139,3,131,195,4,137,7,131,199,
57 4,57,211,15,130,245,3,249,4,139,153,235,129,233,241,137,142,235,195,144,144,
58 144,144,144,144,251,15,249,17,252,246,134,235,237,15,133,245,253,249,6,137,
59 52,36,252,255,146,235,252,246,134,235,237,15,132,245,2,255,137,195,137,52,
60 36,199,68,36,4,239,199,68,36,8,252,255,252,255,252,255,252,255,232,244,137,
61 216,233,245,2,249,7,137,211,137,52,36,199,68,36,4,239,199,68,36,8,252,255,
62 252,255,252,255,252,255,232,244,137,218,233,245,6,251,15,249,14,41,252,248,
63 193,252,248,4,137,190,235,43,158,235,137,76,36,8,137,52,36,137,68,36,4,232,
64 244,139,76,36,8,3,158,235,139,190,235,139,131,235,131,196,12,252,255,160,
65 235,251,15,249,15,137,190,235,137,52,36,232,244,141,136,235,255,139,131,235,
66 137,142,235,131,196,12,252,255,160,235,255,249,18,90,233,245,19,249,20,137,
67 190,235,249,19,137,150,235,137,52,36,232,244,139,158,235,139,190,235,252,
68 255,224,251,15,255,137,190,235,255,232,245,21,255,251,15,249,21,252,246,134,
69 235,237,15,132,245,248,252,255,142,235,15,132,245,247,252,246,134,235,237,
70 15,132,245,248,249,1,139,4,36,131,252,236,12,137,52,36,137,68,36,4,232,244,
71 131,196,12,139,158,235,139,190,235,249,2,195,255,250,255,233,246,255,250,
72 243,255,254,1,233,245,19,254,0,250,254,2,250,251,1,252,255,252,255,254,3,
73 242,0,0,0,0,0,0,0,0,0,254,0,141,249,9,186,239,254,0,249,9,186,239,233,245,
74 20,254,0,139,142,235,139,129,235,191,247,253,59,129,235,15,131,245,22,249,
75 7,255,251,15,249,22,137,52,36,232,244,139,158,235,252,255,231,255,131,187,
76 235,5,15,133,245,9,49,192,137,131,235,137,131,235,254,3,238,238,254,0,131,
77 190,235,0,15,132,245,9,199,134,235,239,129,195,241,255,141,187,235,255,137,
78 158,235,137,190,235,137,52,36,232,244,139,158,235,139,190,235,255,199,135,
79 235,0,0,0,0,255,139,139,235,252,243,15,126,131,235,137,139,235,102,15,214,
80 131,235,255,139,139,235,139,147,235,139,131,235,137,139,235,137,147,235,137,
81 131,235,255,57,223,15,130,245,9,255,131,187,235,8,15,133,245,9,139,131,235,
82 131,184,235,0,15,132,245,9,199,134,235,239,137,190,235,137,52,36,137,92,36,
83 4,199,68,36,8,239,232,244,139,158,235,255,137,199,255,131,187,235,4,15,133,
84 245,9,139,139,235,219,129,235,199,131,235,3,0,0,0,221,155,235,255,141,187,
85 235,232,245,23,137,131,235,199,131,235,4,0,0,0,255,141,187,235,232,245,24,
86 137,131,235,199,131,235,4,0,0,0,255,131,187,235,3,15,133,245,9,141,134,235,
87 221,131,235,219,24,129,56,252,255,0,0,0,15,135,245,9,137,52,36,137,68,36,
88 4,199,68,36,8,1,0,0,0,232,244,137,131,235,199,131,235,4,0,0,0,255,251,15,
89 249,23,139,135,235,193,224,4,11,135,235,193,224,4,11,135,235,45,51,4,0,0,
90 15,133,245,18,221,135,235,221,135,235,219,92,36,8,219,92,36,4,139,143,235,
91 139,185,235,139,84,36,8,57,215,15,130,245,250,249,1,11,68,36,4,15,142,245,
92 252,249,2,41,194,15,140,245,253,141,140,253,1,235,66,249,3,137,116,36,4,137,
93 76,36,8,137,84,36,12,139,190,235,139,135,235,255,59,135,235,15,131,245,254,
94 233,244,249,4,15,140,245,251,141,84,58,1,233,245,1,249,5,137,252,250,233,
95 245,1,249,6,15,132,245,251,1,252,248,64,15,143,245,2,249,5,184,1,0,0,0,233,
96 245,2,249,7,49,210,233,245,3,255,251,15,249,24,139,135,235,193,224,4,11,135,
97 235,131,232,67,15,133,245,18,221,135,235,219,92,36,4,139,143,235,139,185,
98 235,137,252,250,233,245,1,249,8,131,252,236,12,137,52,36,232,244,131,196,
99 12,139,158,235,233,244,255,131,187,235,5,15,133,245,9,255,141,131,235,137,
100 52,36,137,68,36,4,232,244,255,141,131,235,141,139,235,137,52,36,137,68,36,
101 4,137,76,36,8,232,244,255,139,131,235,137,4,36,232,244,137,4,36,219,4,36,
102 221,155,235,199,131,235,3,0,0,0,255,131,187,235,3,15,133,245,9,221,131,235,
103 255,139,131,235,193,224,4,11,131,235,131,252,248,51,15,133,245,9,255,217,
104 252,254,255,217,252,255,255,217,252,242,221,216,255,217,60,36,217,45,239,
105 217,252,252,217,44,36,255,217,225,255,217,252,250,255,221,131,235,221,131,
106 235,249,1,217,252,248,223,224,158,15,138,245,1,221,217,255,221,131,235,221,
107 131,235,217,252,243,255,221,28,36,232,244,255,131,187,235,6,15,133,245,9,
108 129,187,235,239,15,133,245,9,255,141,131,235,57,199,15,133,245,9,255,141,
109 187,235,137,190,235,255,131,196,12,129,252,235,241,129,174,235,241,195,255,
110 141,187,235,137,52,36,137,124,36,4,232,244,133,192,15,133,246,255,139,131,
111 235,64,139,147,235,137,131,235,137,20,36,137,68,36,4,232,244,139,136,235,
112 133,201,15,132,245,255,219,131,235,199,131,235,3,0,0,0,221,155,235,139,144,
113 235,139,128,235,137,139,235,137,147,235,137,131,235,233,246,249,9,255,141,
114 135,235,131,252,236,12,59,134,235,15,131,245,14,59,142,235,141,137,235,15,
115 132,245,15,49,192,137,153,235,129,195,241,137,142,235,255,141,147,235,57,
116 215,255,137,223,255,15,71,252,250,255,15,134,245,247,137,215,249,1,255,141,
117 147,235,137,129,235,137,145,235,137,150,235,137,158,235,137,153,235,255,15,
118 130,245,251,249,4,254,2,249,5,137,135,235,129,199,241,57,215,15,130,245,5,
119 233,245,4,254,0,137,190,235,137,185,235,137,129,235,255,139,139,235,252,243,
120 15,126,131,235,137,143,235,102,15,214,135,235,255,139,139,235,139,147,235,
121 137,143,235,139,139,235,137,151,235,137,143,235,255,137,252,251,141,147,235,
122 141,187,235,137,145,235,137,150,235,255,137,135,235,255,249,2,137,135,235,
123 137,135,235,129,199,241,57,215,15,130,245,2,255,137,52,36,232,244,255,252,
124 246,134,235,237,15,132,245,255,232,245,25,249,9,255,251,15,249,25,139,142,
125 235,139,185,235,139,135,235,139,184,235,139,135,235,131,192,4,137,134,235,
126 131,252,236,12,137,52,36,199,68,36,4,239,199,68,36,8,252,255,252,255,252,
127 255,252,255,232,244,131,196,12,139,135,235,137,134,235,139,158,235,195,255,
128 137,52,36,137,92,36,4,232,244,255,129,174,235,241,137,223,129,252,235,241,
129 131,196,12,255,139,142,235,139,153,235,129,233,241,137,142,235,141,187,235,
130 131,196,12,255,252,246,134,235,237,15,132,245,253,232,245,26,249,7,255,139,
131 68,36,12,137,134,235,255,251,15,249,26,139,4,36,137,134,235,131,252,236,12,
132 137,52,36,199,68,36,4,239,199,68,36,8,252,255,252,255,252,255,252,255,232,
133 244,131,196,12,139,158,235,139,190,235,195,255,139,145,235,57,252,251,15,
134 131,245,248,249,1,139,3,131,195,4,137,2,131,194,4,57,252,251,15,130,245,1,
135 249,2,131,196,12,139,153,235,129,233,241,137,215,137,142,235,195,255,129,
136 174,235,241,129,252,235,241,255,131,196,12,141,187,235,195,255,139,142,235,
137 139,185,235,129,233,241,137,142,235,255,139,139,235,139,147,235,139,131,235,
138 137,143,235,137,151,235,137,135,235,255,131,196,12,137,252,251,255,129,199,
139 241,255,139,142,235,131,187,235,6,255,139,131,235,186,239,137,145,235,255,
140 15,133,245,20,255,15,133,245,19,255,15,132,245,247,232,245,27,249,1,255,251,
141 15,249,27,131,252,236,12,137,150,235,137,190,235,137,52,36,137,92,36,4,232,
142 244,131,196,12,137,195,139,190,235,139,131,235,139,142,235,195,255,252,255,
143 144,235,255,137,158,235,255,49,192,255,141,147,235,249,1,137,135,235,137,
144 135,235,129,199,241,57,215,15,130,245,1,255,131,187,235,6,15,133,245,9,255,
145 131,187,235,6,15,133,245,251,254,2,249,5,255,186,239,233,245,28,254,0,251,
146 15,249,28,137,150,235,137,190,235,137,52,36,137,92,36,4,232,244,139,142,235,
147 139,150,235,139,185,235,249,1,139,24,131,192,4,137,31,131,199,4,57,208,15,
148 130,245,1,139,153,235,139,131,235,129,233,241,131,196,12,252,255,160,235,
149 255,139,131,235,255,139,139,235,139,147,235,137,139,235,139,139,235,137,147,
150 235,137,139,235,255,141,187,235,129,252,235,241,139,142,235,137,131,235,255,
151 139,142,235,141,187,235,139,153,235,139,135,235,137,131,235,255,139,135,235,
152 252,243,15,126,135,235,137,131,235,102,15,214,131,235,255,139,135,235,139,
153 151,235,137,131,235,139,135,235,137,147,235,137,131,235,255,141,187,235,139,
154 131,235,255,139,145,235,249,1,139,3,131,195,4,137,2,131,194,4,57,252,251,
155 15,130,245,1,139,153,235,137,215,139,131,235,255,199,131,235,0,0,0,0,255,
156 186,1,0,0,0,137,147,235,137,147,235,255,199,131,235,0,0,0,0,199,131,235,1,
157 0,0,0,255,217,252,238,255,217,232,255,221,5,239,255,199,131,235,239,199,131,
158 235,4,0,0,0,255,137,131,235,195,255,141,139,235,141,147,235,249,1,137,1,57,
159 209,141,137,235,15,134,245,1,255,139,142,235,139,185,235,139,135,235,255,
160 139,136,235,139,185,235,255,139,143,235,252,243,15,126,135,235,137,139,235,
161 102,15,214,131,235,255,139,143,235,139,151,235,139,135,235,137,139,235,137,
162 147,235,137,131,235,255,139,136,235,139,185,235,139,131,235,139,147,235,137,
163 135,235,131,252,248,4,139,131,235,137,151,235,137,135,235,15,131,245,251,
164 249,4,254,2,249,5,252,246,130,235,237,15,132,245,4,252,246,129,235,237,15,
165 132,245,4,232,245,29,233,245,4,254,0,251,15,249,29,137,84,36,12,137,76,36,
166 8,137,116,36,4,233,244,255,251,15,249,30,139,142,235,139,185,235,139,135,
167 235,139,184,235,233,245,255,255,251,15,249,31,131,191,235,5,139,191,235,15,
168 133,245,18,249,9,15,182,143,235,184,1,0,0,0,211,224,72,35,130,235,193,224,
169 5,3,135,235,249,1,131,184,235,4,15,133,245,248,57,144,235,15,133,245,248,
170 139,136,235,133,201,15,132,245,249,255,252,243,15,126,128,235,102,15,214,
171 131,235,255,139,144,235,139,184,235,137,147,235,137,187,235,255,137,139,235,
172 139,158,235,195,249,2,139,128,235,133,192,15,133,245,1,49,201,249,3,139,135,
173 235,133,192,15,132,245,250,252,246,128,235,237,15,132,245,251,249,4,137,139,
174 235,139,158,235,195,249,5,137,150,235,199,134,235,4,0,0,0,139,12,36,131,252,
175 236,12,137,142,235,137,52,36,137,124,36,4,137,92,36,8,232,244,131,196,12,
176 139,158,235,255,251,15,249,32,139,135,235,193,224,4,11,129,235,131,252,248,
177 84,139,191,235,139,145,235,15,132,245,9,233,245,18,255,251,15,249,33,139,
178 142,235,128,167,235,237,139,145,235,137,185,235,137,151,235,195,255,251,15,
179 249,34,139,142,235,139,185,235,139,135,235,139,184,235,233,245,255,255,251,
180 15,249,35,131,191,235,5,139,191,235,15,133,245,18,249,9,15,182,143,235,184,
181 1,0,0,0,211,224,72,35,130,235,193,224,5,3,135,235,249,1,131,184,235,4,15,
182 133,245,250,57,144,235,15,133,245,250,131,184,235,0,15,132,245,252,249,2,
183 198,135,235,0,249,3,255,252,246,135,235,237,15,133,245,254,249,7,255,139,
184 139,235,252,243,15,126,131,235,137,136,235,102,15,214,128,235,255,139,139,
185 235,139,147,235,139,187,235,137,136,235,137,144,235,137,184,235,255,139,158,
186 235,195,249,8,232,245,33,233,245,7,249,4,139,128,235,133,192,15,133,245,1,
187 139,143,235,133,201,15,132,245,251,252,246,129,235,237,15,132,245,253,249,
188 5,141,134,235,137,144,235,199,128,235,4,0,0,0,131,252,236,12,137,52,36,137,
189 124,36,4,137,68,36,8,232,244,131,196,12,233,245,2,249,6,255,139,143,235,133,
190 201,15,132,245,2,252,246,129,235,237,15,133,245,2,249,7,137,150,235,199,134,
191 235,4,0,0,0,139,12,36,131,252,236,12,137,142,235,137,52,36,137,124,36,4,137,
192 92,36,8,232,244,131,196,12,139,158,235,195,255,251,15,249,36,139,135,235,
193 193,224,4,11,129,235,131,252,248,84,139,191,235,139,145,235,15,132,245,9,
194 233,245,18,255,137,52,36,199,68,36,4,239,199,68,36,8,239,232,244,137,131,
195 235,199,131,235,5,0,0,0,255,186,239,255,232,245,30,255,232,245,34,255,141,
196 187,235,186,239,255,141,187,235,141,139,235,255,131,187,235,5,139,187,235,
197 15,133,245,255,185,239,139,135,235,59,143,235,15,135,245,251,255,139,131,
198 235,193,224,4,11,131,235,131,252,248,83,15,133,245,255,255,252,242,15,16,
199 131,235,252,242,15,44,192,252,242,15,42,200,72,102,15,46,200,139,187,235,
200 15,133,245,255,15,138,245,255,255,221,131,235,219,20,36,219,4,36,255,223,
201 233,221,216,255,218,233,223,224,158,255,15,133,245,255,15,138,245,255,139,
202 4,36,139,187,235,72,255,59,135,235,15,131,245,251,193,224,4,3,135,235,255,
203 232,245,31,255,232,245,32,255,185,239,255,141,147,235,255,199,134,235,239,
204 83,81,82,86,232,244,131,196,16,139,158,235,255,249,1,139,144,235,133,210,
205 15,132,245,252,255,139,136,235,139,128,235,137,139,235,137,131,235,255,249,
206 2,137,147,235,254,2,232,245,37,255,232,245,38,255,233,245,1,249,6,139,143,
207 235,133,201,15,132,245,2,252,246,129,235,237,15,133,245,2,249,9,186,239,233,
208 245,19,254,0,251,15,249,37,137,76,36,4,131,252,236,12,137,60,36,137,76,36,
209 4,232,244,131,196,12,139,76,36,4,193,225,4,41,200,129,192,241,195,255,251,
210 15,249,38,64,137,124,36,4,137,68,36,8,233,244,255,187,239,255,232,245,35,
211 255,232,245,36,255,199,134,235,239,82,81,83,86,232,244,131,196,16,139,158,
212 235,255,249,1,131,184,235,0,15,132,245,252,249,2,254,2,232,245,39,255,232,
213 245,40,255,252,246,135,235,237,15,133,245,253,249,3,254,2,249,7,232,245,33,
214 233,245,3,254,0,199,128,235,0,0,0,0,255,186,1,0,0,0,137,144,235,137,144,235,
215 255,199,128,235,0,0,0,0,199,128,235,1,0,0,0,255,221,152,235,199,128,235,3,
216 0,0,0,255,199,128,235,239,199,128,235,4,0,0,0,255,251,15,249,39,137,76,36,
217 4,131,252,236,12,137,52,36,137,124,36,4,137,76,36,8,232,244,131,196,12,139,
218 76,36,4,193,225,4,41,200,129,192,241,195,255,251,15,249,40,64,137,116,36,
219 4,137,124,36,8,137,68,36,12,233,244,255,137,190,235,141,131,235,41,252,248,
220 252,247,216,193,252,248,4,139,187,235,15,132,245,250,255,129,192,241,255,
221 57,135,235,15,131,245,247,137,52,36,137,124,36,4,137,68,36,8,232,244,249,
222 1,252,246,135,235,237,139,151,235,15,133,245,252,139,190,235,254,2,249,6,
223 232,245,33,233,245,1,254,0,139,187,235,129,191,235,241,15,130,245,251,249,
224 1,252,246,135,235,237,139,151,235,15,133,245,252,141,187,235,254,2,249,5,
225 137,52,36,137,124,36,4,199,68,36,8,239,232,244,233,245,1,249,6,232,245,33,
226 233,245,1,254,0,129,194,241,255,141,139,235,249,3,139,1,131,193,4,137,2,131,
227 194,4,57,252,249,15,130,245,3,249,4,255,131,187,235,3,139,131,235,15,133,
228 245,255,133,192,15,136,245,255,255,221,131,235,221,5,239,255,221,5,239,221,
229 131,235,255,139,131,235,193,224,4,11,131,235,131,252,248,51,139,131,235,15,
230 133,245,255,11,131,235,15,136,245,255,221,131,235,221,131,235,255,131,187,
231 235,3,15,133,245,255,221,131,235,255,216,200,255,217,192,216,200,255,220,
232 201,255,222,201,255,199,4,36,239,199,68,36,4,239,199,68,36,8,239,131,187,
233 235,3,15,133,245,255,219,44,36,220,139,235,217,192,217,252,252,220,233,217,
234 201,217,252,240,217,232,222,193,217,252,253,221,217,255,251,15,249,41,217,
235 232,221,68,36,8,217,252,241,139,68,36,4,219,56,195,255,131,187,235,3,15,133,
236 245,255,255,131,187,235,3,255,139,131,235,193,224,4,11,131,235,131,252,248,
237 51,255,216,192,255,220,131,235,255,220,163,235,255,220,171,235,255,220,139,
238 235,255,220,179,235,255,220,187,235,255,131,252,236,16,221,28,36,221,131,
239 235,221,92,36,8,232,244,131,196,16,255,131,252,236,16,221,92,36,8,221,131,
240 235,221,28,36,232,244,131,196,16,255,217,224,255,15,138,246,255,15,130,246,
241 255,15,134,246,255,15,135,246,255,15,131,246,255,199,134,235,239,137,52,36,
242 137,76,36,4,137,84,36,8,232,244,133,192,139,158,235,255,15,132,246,255,199,
243 134,235,239,199,4,36,239,82,81,83,86,232,244,131,196,16,139,158,235,255,131,
244 187,235,5,139,139,235,15,133,245,9,137,12,36,232,244,137,4,36,219,4,36,221,
245 155,235,199,131,235,3,0,0,0,255,131,187,235,4,139,139,235,15,133,245,9,219,
246 129,235,221,155,235,199,131,235,3,0,0,0,255,199,134,235,239,137,52,36,137,
247 92,36,4,137,76,36,8,232,244,139,158,235,255,139,131,235,139,139,235,186,1,
248 0,0,0,33,193,209,232,9,193,49,192,57,209,17,192,137,147,235,137,131,235,255,
249 232,245,42,137,131,235,199,131,235,4,0,0,0,255,199,134,235,239,137,52,36,
250 199,68,36,4,239,199,68,36,8,239,232,244,139,158,235,255,251,15,249,42,137,
251 116,36,4,139,131,235,193,224,4,11,131,235,131,232,68,15,133,245,18,249,1,
252 139,190,235,139,179,235,139,147,235,139,142,235,133,201,15,132,245,248,11,
253 130,235,15,132,245,250,1,200,15,130,245,255,59,135,235,15,135,245,251,139,
254 191,235,129,198,241,255,252,243,164,139,138,235,141,178,235,252,243,164,41,
255 199,139,116,36,4,137,124,36,8,137,68,36,12,139,158,235,233,244,249,2,137,
256 208,249,3,139,116,36,4,139,158,235,195,249,4,137,252,240,233,245,3,249,5,
257 139,116,36,4,141,143,235,131,252,236,12,137,52,36,137,76,36,4,137,68,36,8,
258 232,244,131,196,12,49,192,233,245,1,249,9,139,116,36,4,233,245,18,255,131,
259 187,235,0,255,139,131,235,139,139,235,72,73,9,200,255,139,131,235,72,11,131,
260 235,255,131,187,235,3,15,133,246,221,131,235,221,5,239,255,131,187,235,4,
261 15,133,246,129,187,235,239,255,139,131,235,59,131,235,15,133,246,255,131,
262 252,248,3,15,133,245,9,221,131,235,221,131,235,255,131,252,248,4,15,133,245,
263 9,139,139,235,59,139,235,255,141,147,235,141,139,235,199,134,235,239,137,
264 52,36,137,76,36,4,137,84,36,8,232,244,72,139,158,235,255,139,131,235,139,
265 139,235,137,194,33,202,141,20,80,209,234,255,15,132,245,247,255,15,133,245,
266 247,255,139,147,235,137,131,235,137,139,235,137,147,235,233,246,249,1,255,
267 139,131,235,193,224,4,11,131,235,131,252,248,51,15,133,245,255,249,4,221,
268 131,235,221,131,235,221,147,235,255,249,4,139,131,235,193,224,4,11,131,235,
269 193,224,4,11,131,235,61,51,3,0,0,139,131,235,15,133,245,255,221,131,235,221,
270 131,235,133,192,221,147,235,15,136,245,247,217,201,249,1,255,199,131,235,
271 3,0,0,0,15,130,246,255,249,9,141,131,235,199,134,235,239,137,52,36,137,68,
272 36,4,232,244,233,245,4,254,0,221,131,235,221,131,235,220,131,235,221,147,
273 235,221,147,235,199,131,235,3,0,0,0,255,139,131,235,221,131,235,221,131,235,
274 221,131,235,222,193,221,147,235,221,147,235,199,131,235,3,0,0,0,133,192,15,
275 136,245,247,217,201,249,1,255,131,187,235,0,15,132,245,247,255,141,131,235,
276 137,68,36,4,255,137,92,36,4,255,139,187,235,255,139,142,235,139,185,235,139,
277 191,235,255,139,151,235,137,52,36,199,68,36,4,239,137,84,36,8,232,244,199,
278 128,235,239,137,131,235,199,131,235,6,0,0,0,255,139,151,235,137,144,235,255,
279 137,52,36,232,244,137,135,235,255,249,1,139,142,235,139,145,235,129,194,241,
280 141,132,253,27,235,41,208,59,134,235,15,131,245,251,141,187,235,57,218,15,
281 131,245,249,249,2,139,2,131,194,4,137,7,131,199,4,57,218,15,130,245,2,249,
282 3,254,2,249,5,43,134,235,193,252,248,4,137,52,36,137,68,36,4,232,244,139,
283 158,235,233,245,1,254,0,139,142,235,139,145,235,129,194,241,141,187,235,141,
284 139,235,57,218,15,131,245,248,249,1,139,2,131,194,4,137,7,131,199,4,57,207,
285 15,131,245,250,57,218,15,130,245,1,249,2,49,192,249,3,137,135,235,129,199,
286 241,57,207,15,130,245,3,249,4,255
287};
288
289enum {
290 JSUB_STACKPTR,
291 JSUB_GATE_LJ,
292 JSUB_GATE_JL,
293 JSUB_GATE_JC,
294 JSUB_GROW_STACK,
295 JSUB_GROW_CI,
296 JSUB_GATE_JC_PATCH,
297 JSUB_GATE_JC_DEBUG,
298 JSUB_DEOPTIMIZE_CALLER,
299 JSUB_DEOPTIMIZE,
300 JSUB_DEOPTIMIZE_OPEN,
301 JSUB_HOOKINS,
302 JSUB_GCSTEP,
303 JSUB_STRING_SUB3,
304 JSUB_STRING_SUB2,
305 JSUB_HOOKCALL,
306 JSUB_HOOKRET,
307 JSUB_METACALL,
308 JSUB_METATAILCALL,
309 JSUB_BARRIERF,
310 JSUB_GETGLOBAL,
311 JSUB_GETTABLE_KSTR,
312 JSUB_GETTABLE_STR,
313 JSUB_BARRIERBACK,
314 JSUB_SETGLOBAL,
315 JSUB_SETTABLE_KSTR,
316 JSUB_SETTABLE_STR,
317 JSUB_GETTABLE_KNUM,
318 JSUB_GETTABLE_NUM,
319 JSUB_SETTABLE_KNUM,
320 JSUB_SETTABLE_NUM,
321 JSUB_LOG2_TWORD,
322 JSUB_CONCAT_STR2,
323 JSUB__MAX
324};
325
326/* ------------------------------------------------------------------------ */
327
328/* Arch string. */
329const char luaJIT_arch[] = "x86";
330
331/* Forward declarations for C functions called from jsubs. */
332static void jit_hookins(lua_State *L, const Instruction *newpc);
333static void jit_gettable_fb(lua_State *L, Table *t, StkId dest);
334static void jit_settable_fb(lua_State *L, Table *t, StkId val);
335
336/* ------------------------------------------------------------------------ */
337
338/* Detect CPU features and set JIT flags. */
339static int jit_cpudetect(jit_State *J)
340{
341 void *mcode;
342 size_t sz;
343 int status;
344 /* Some of the jsubs need the flags. So compile this separately. */
345 unsigned int feature;
346 dasm_setup(Dst, jit_actionlist);
347 dasm_put(Dst, 0);
348 (void)dasm_checkstep(Dst, DASM_SECTION_CODE);
349 status = luaJIT_link(J, &mcode, &sz);
350 if (status != JIT_S_OK)
351 return status;
352 /* Check feature bits. See the Intel/AMD manuals for the bit definitions. */
353 feature = ((unsigned int (*)(void))mcode)();
354 if (feature & (1<<15)) J->flags |= JIT_F_CPU_CMOV;
355 if (feature & (1<<26)) J->flags |= JIT_F_CPU_SSE2;
356 luaJIT_freemcode(J, mcode, sz); /* We don't need this code anymore. */
357 return JIT_S_OK;
358}
359
360/* Check some assumptions. Should compile to nop. */
361static int jit_consistency_check(jit_State *J)
362{
363 do {
364 /* Force a compiler error for inconsistent structure sizes. */
365 /* Check LUA_TVALUE_ALIGN in luaconf.h, too. */
366 int check_TVALUE_SIZE_in_ljit_x86_dash[1+16-sizeof(TValue)];
367 int check_TVALUE_SIZE_in_ljit_x86_dash_[1+sizeof(TValue)-16];
368 ((void)check_TVALUE_SIZE_in_ljit_x86_dash[0]);
369 ((void)check_TVALUE_SIZE_in_ljit_x86_dash_[0]);
370 if (LUA_TNIL != 0 || LUA_TBOOLEAN != 1 || PCRLUA != 0) break;
371 if ((int)&(((Node *)0)->i_val) != (int)&(((StkId)0)->value)) break;
372 return JIT_S_OK;
373 } while (0);
374 J->dasmstatus = 999999999; /* Recognizable error. */
375 return JIT_S_COMPILER_ERROR;
376}
377
378/* Compile JIT subroutines (once). */
379static int jit_compile_jsub(jit_State *J)
380{
381 int status = jit_consistency_check(J);
382 if (status != JIT_S_OK) return status;
383 status = jit_cpudetect(J);
384 if (status != JIT_S_OK) return status;
385 dasm_setup(Dst, jit_actionlist);
386 dasm_put(Dst, 34);
387 dasm_put(Dst, 36, Dt1(->top), Dt2(->value), Dt1(->ci), Dt1(->nCcalls), Dt5(->jit_gate), Dt1(->ci), Dt1(->top), Dt4(->savedpc), Dt1(->savedpc), Dt4(->base), Dt1(->base), Dt1(->top), Dt3(->tt), sizeof(TValue));
388 dasm_put(Dst, 145, Dt1(->nCcalls), PCRC, Dt5(->p), DtE(->jit_status), JIT_S_OK, DtE(->jit_mcode), Dt5(->jit_gate), Dt4(->savedpc), Dt1(->ci), Dt1(->top), Dt1(->savedpc), Dt1(->stack), (ptrdiff_t)(luaD_precall), (ptrdiff_t)(luaV_execute), Dt1(->stack));
389 dasm_put(Dst, 262, Dt1(->top), Dt3([LUA_MINSTACK]), Dt1(->stack_last), Dt1(->end_ci), Dt4([1]), Dt1(->ci), Dt4(->func), Dt4(->top), Dt2(->value), sizeof(TValue), Dt1(->top), Dt1(->base), Dt4(->base), DtD(->f), Dt1(->ci));
390 dasm_put(Dst, 336, Dt4(->func), Dt1(->top), Dt4(->func), sizeof(CallInfo), Dt1(->ci), Dt1(->hookmask), LUA_MASKCALL, DtD(->f), Dt1(->hookmask), LUA_MASKRET);
391 dasm_put(Dst, 421, LUA_HOOKRET, (ptrdiff_t)(luaD_callhook), LUA_HOOKCALL, (ptrdiff_t)(luaD_callhook), Dt1(->top), Dt1(->stack), (ptrdiff_t)(luaD_growstack), Dt1(->stack), Dt1(->top), Dt2(->value), Dt5(->jit_gate), Dt1(->top), (ptrdiff_t)(luaD_growCI), Dt9([-1]));
392 dasm_put(Dst, 547, Dt2(->value), Dt1(->ci), Dt5(->jit_gate));
393 dasm_put(Dst, 602, Dt1(->hookmask), LUA_MASKLINE|LUA_MASKCOUNT, Dt1(->hookcount), Dt1(->hookmask), LUA_MASKLINE, (ptrdiff_t)(jit_hookins), Dt1(->base), Dt1(->top));
394 dasm_put(Dst, 737, (ptrdiff_t)(luaC_step), Dt1(->base));
395 dasm_put(Dst, 1026, Dt3([0].tt), Dt3([1].tt), Dt3([2].tt), Dt3([1].value), Dt3([2].value), Dt3([0].value), DtB(->tsv.len), sizeof(TString)-1, Dt1(->l_G), Dt6(->totalbytes));
396 dasm_put(Dst, 1129, Dt6(->GCthreshold), (ptrdiff_t)(luaS_newlstr));
397 dasm_put(Dst, 1191, Dt3([0].tt), Dt3([1].tt), Dt3([1].value), Dt3([0].value), DtB(->tsv.len), (ptrdiff_t)(luaC_step), Dt1(->base), (ptrdiff_t)(luaS_newlstr));
398 dasm_put(Dst, 1755, Dt1(->ci), Dt4(->func), Dt3(->value), Dt5(->p), DtE(->code), Dt1(->savedpc), LUA_HOOKCALL, (ptrdiff_t)(luaD_callhook), DtE(->code), Dt1(->savedpc), Dt1(->base));
399 dasm_put(Dst, 1886, Dt1(->savedpc), LUA_HOOKRET, (ptrdiff_t)(luaD_callhook), Dt1(->base), Dt1(->top));
400 dasm_put(Dst, 2077, Dt1(->savedpc), Dt1(->top), (ptrdiff_t)(luaD_tryfuncTM), Dt1(->top), Dt2(->value), Dt1(->ci));
401 dasm_put(Dst, 2178, Dt1(->savedpc), Dt1(->top), (ptrdiff_t)(luaD_tryfuncTM), Dt1(->ci), Dt1(->top), Dt4(->func), Dt4(->func), Dt2(->value), sizeof(CallInfo), Dt5(->jit_gate));
402 dasm_put(Dst, 2570, (ptrdiff_t)(luaC_barrierf));
403 dasm_put(Dst, 2589, Dt1(->ci), Dt4(->func), Dt3(->value), Dt5(->env));
404 dasm_put(Dst, 2609, Dt3(->tt), Dt3(->value), DtC(->lsizenode), DtB(->tsv.hash), DtC(->node), Dt10(->i_key.nk.tt), Dt10(->i_key.nk.value), Dt10(->i_val.tt));
405 if (J->flags & JIT_F_CPU_SSE2) {
406 dasm_put(Dst, 2674, Dt10(->i_val.value), Dt2(->value));
407 } else {
408 dasm_put(Dst, 2686, Dt10(->i_val.value), Dt10(->i_val.value.na[1]), Dt2(->value), Dt2(->value.na[1]));
409 }
410 dasm_put(Dst, 2699, Dt2(->tt), Dt1(->base), Dt10(->i_key.nk.next), DtC(->metatable), DtC(->flags), 1<<TM_INDEX, Dt2([0].tt), Dt1(->base), Dt1(->env.value), Dt1(->env.tt), Dt1(->savedpc), (ptrdiff_t)(jit_gettable_fb), Dt1(->base));
411 dasm_put(Dst, 32);
412 dasm_put(Dst, 2790, Dt3(->tt), Dt7(->tt), Dt3(->value), Dt7(->value));
413 dasm_put(Dst, 2821, Dt1(->l_G), DtC(->marked), (~bitmask(BLACKBIT))&0xff, Dt6(->grayagain), Dt6(->grayagain), DtC(->gclist));
414 dasm_put(Dst, 2843, Dt1(->ci), Dt4(->func), Dt3(->value), Dt5(->env));
415 dasm_put(Dst, 2863, Dt3(->tt), Dt3(->value), DtC(->lsizenode), DtB(->tsv.hash), DtC(->node), Dt10(->i_key.nk.tt), Dt10(->i_key.nk.value), Dt10(->i_val.tt), DtC(->flags));
416 dasm_put(Dst, 2935, DtC(->marked), bitmask(BLACKBIT));
417 if (J->flags & JIT_F_CPU_SSE2) {
418 dasm_put(Dst, 2947, Dt2([0].tt), Dt2([0].value), Dt7([0].tt), Dt7([0].value));
419 } else {
420 dasm_put(Dst, 2965, Dt2([0].value), Dt2([0].value.na[1]), Dt2([0].tt), Dt7([0].value), Dt7([0].value.na[1]), Dt7([0].tt));
421 }
422 dasm_put(Dst, 2984, Dt1(->base), Dt10(->i_key.nk.next), DtC(->metatable), DtC(->flags), 1<<TM_NEWINDEX, Dt1(->env), Dt7([0].value), Dt7([0].tt), (ptrdiff_t)(luaH_newkey));
423 dasm_put(Dst, 3066, DtC(->metatable), DtC(->flags), 1<<TM_NEWINDEX, Dt1(->env.value), Dt1(->env.tt), Dt1(->savedpc), (ptrdiff_t)(jit_settable_fb), Dt1(->base));
424 dasm_put(Dst, 3127, Dt3(->tt), Dt7(->tt), Dt3(->value), Dt7(->value));
425 dasm_put(Dst, 3438, (ptrdiff_t)(luaH_getnum), sizeof(TValue));
426 dasm_put(Dst, 3476, (ptrdiff_t)(luaH_getnum));
427 dasm_put(Dst, 3623, (ptrdiff_t)(luaH_setnum), sizeof(TValue));
428 dasm_put(Dst, 3665, (ptrdiff_t)(luaH_setnum));
429 dasm_put(Dst, 3992);
430 dasm_put(Dst, 4325, Dt2([0].tt), Dt2([1].tt), Dt1(->l_G), Dt2([0].value), Dt2([1].value), DtB(->tsv.len), DtB(->tsv.len), Dt6(->buff.buffsize), Dt6(->buff.buffer), sizeof(TString));
431 dasm_put(Dst, 4396, DtB(->tsv.len), DtB([1]), Dt1(->base), (ptrdiff_t)(luaS_newlstr), Dt1(->base), Dt6(->buff), (ptrdiff_t)(luaZ_openspace));
432 dasm_put(Dst, 561, Dt1(->top), Dt1(->savedpc), (ptrdiff_t)(luaJIT_deoptimize), Dt1(->base), Dt1(->top));
433
434 (void)dasm_checkstep(Dst, DASM_SECTION_CODE);
435 status = luaJIT_link(J, &J->jsubmcode, &J->szjsubmcode);
436 if (status != JIT_S_OK)
437 return status;
438
439 /* Copy the callgates from the globals to the global state. */
440 G(J->L)->jit_gateLJ = (luaJIT_GateLJ)J->jsub[JSUB_GATE_LJ];
441 G(J->L)->jit_gateJL = (lua_CFunction)J->jsub[JSUB_GATE_JL];
442 G(J->L)->jit_gateJC = (lua_CFunction)J->jsub[JSUB_GATE_JC];
443 return JIT_S_OK;
444}
445
446/* Match with number of nops above. Avoid confusing the instruction decoder. */
447#define DEBUGPATCH_SIZE 6
448
449/* Notify backend that the debug mode may have changed. */
450void luaJIT_debugnotify(jit_State *J)
451{
452 unsigned char *patch = (unsigned char *)J->jsub[JSUB_GATE_JC_PATCH];
453 unsigned char *target = (unsigned char *)J->jsub[JSUB_GATE_JC_DEBUG];
454 /* Yep, this is self-modifying code -- don't tell anyone. */
455 if (patch[0] == 0xe9) { /* Debug patch is active. */
456 if (!(J->flags & JIT_F_DEBUG_CALL)) /* Deactivate it. */
457 memcpy(patch, target-DEBUGPATCH_SIZE, DEBUGPATCH_SIZE);
458 } else { /* Debug patch is inactive. */
459 if (J->flags & JIT_F_DEBUG_CALL) { /* Activate it. */
460 int rel = target-(patch+5);
461 memcpy(target-DEBUGPATCH_SIZE, patch, DEBUGPATCH_SIZE);
462 patch[0] = 0xe9; /* jmp */
463 memcpy(patch+1, &rel, 4); /* Relative address. */
464 memset(patch+5, 0x90, DEBUGPATCH_SIZE-5); /* nop */
465 }
466 }
467}
468
469/* Patch a jmp into existing mcode. */
470static void jit_patch_jmp(jit_State *J, void *mcode, void *to)
471{
472 unsigned char *patch = (unsigned char *)mcode;
473 int rel = ((unsigned char *)to)-(patch+5);
474 patch[0] = 0xe9; /* jmp */
475 memcpy((void *)(patch+1), &rel, 4); /* Relative addr. */
476}
477
478/* ------------------------------------------------------------------------ */
479
480/* Call line/count hook. */
481static void jit_hookins(lua_State *L, const Instruction *newpc)
482{
483 Proto *pt = ci_func(L->ci)->l.p;
484 int pc = luaJIT_findpc(pt, newpc); /* Sloooow with mcode addrs. */
485 const Instruction *savedpc = L->savedpc;
486 L->savedpc = pt->code + pc + 1;
487 if (L->hookmask > LUA_MASKLINE && L->hookcount == 0) {
488 resethookcount(L);
489 luaD_callhook(L, LUA_HOOKCOUNT, -1);
490 }
491 if (L->hookmask & LUA_MASKLINE) {
492 int newline = getline(pt, pc);
493 if (pc != 0) {
494 int oldpc = luaJIT_findpc(pt, savedpc);
495 if (!(pc <= oldpc || newline != getline(pt, oldpc))) return;
496 }
497 luaD_callhook(L, LUA_HOOKLINE, newline);
498 }
499}
500
501/* Insert hook check for each instruction in full debug mode. */
502static void jit_ins_debug(jit_State *J, int openop)
503{
504 if (openop) {
505 dasm_put(Dst, 594, Dt1(->top));
506 }
507 dasm_put(Dst, 598);
508
509}
510
511/* Called before every instruction. */
512static void jit_ins_start(jit_State *J)
513{
514 dasm_put(Dst, 663, J->nextpc);
515}
516
517/* Chain to another instruction. */
518static void jit_ins_chainto(jit_State *J, int pc)
519{
520 dasm_put(Dst, 665, pc);
521}
522
523/* Set PC label. */
524static void jit_ins_setpc(jit_State *J, int pc, void *target)
525{
526 dasm_put(Dst, 668, pc, (ptrdiff_t)(target));
527}
528
529/* Called after the last instruction has been encoded. */
530static void jit_ins_last(jit_State *J, int lastpc, int sizemfm)
531{
532 if (J->tflags & JIT_TF_USED_DEOPT) { /* Deopt section has been used? */
533 dasm_put(Dst, 671);
534 dasm_put(Dst, 673);
535 }
536 dasm_put(Dst, 678, lastpc+1);
537 dasm_put(Dst, 681, lastpc+2);
538 dasm_put(Dst, 690, sizemfm);
539}
540
541/* Add a deoptimize target for the current instruction. */
542static void jit_deopt_target(jit_State *J, int nargs)
543{
544 if (nargs != -1) {
545 dasm_put(Dst, 671);
546 dasm_put(Dst, 702, (ptrdiff_t)(J->nextins));
547 J->tflags |= JIT_TF_USED_DEOPT;
548 } else {
549 dasm_put(Dst, 679);
550 dasm_put(Dst, 709, (ptrdiff_t)(J->nextins));
551 }
552}
553
554/* luaC_checkGC() inlined. Destroys caller-saves + TOP (edi). Uses label 7:. */
555/* Use this only at the _end_ of an instruction. */
556static void jit_checkGC(jit_State *J)
557{
558 dasm_put(Dst, 718, Dt1(->l_G), Dt6(->totalbytes), Dt6(->GCthreshold));
559
560}
561
562/* ------------------------------------------------------------------------ */
563
564
565
566/*
567** Function inlining support for x86 CPUs.
568** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
569*/
570
571/* ------------------------------------------------------------------------ */
572
573/* Private structure holding function inlining info. */
574typedef struct jit_InlineInfo {
575 int func; /* Function slot. 1st arg slot = func+1. */
576 int res; /* 1st result slot. Overlaps func/ci->func. */
577 int nargs; /* Number of args. */
578 int nresults; /* Number of results. */
579 int xnargs; /* Expected number of args. */
580 int xnresults; /* Returned number of results. */
581 int hidx; /* Library/function index numbers. */
582} jit_InlineInfo;
583
584/* ------------------------------------------------------------------------ */
585
586enum { TFOR_FUNC, TFOR_TAB, TFOR_CTL, TFOR_KEY, TFOR_VAL };
587
588static void jit_inline_base(jit_State *J, jit_InlineInfo *ii)
589{
590 int func = ii->func;
591 switch (JIT_IH_IDX(ii->hidx)) {
592 case JIT_IH_BASE_PAIRS:
593 case JIT_IH_BASE_IPAIRS:
594 dasm_put(Dst, 753, Dt2([func+TFOR_TAB].tt), Dt2([func+TFOR_CTL].tt), Dt2([func+TFOR_CTL].value));
595 dasm_put(Dst, 771, JIT_MFM_DEOPT_PAIRS, J->nextpc-1);
596 break;
597 default:
598 jit_assert(0);
599 break;
600 }
601}
602
603/* ------------------------------------------------------------------------ */
604
605#ifndef COCO_DISABLE
606
607/* Helper function for inlined coroutine.resume(). */
608static StkId jit_coroutine_resume(lua_State *L, StkId base, int nresults)
609{
610 lua_State *co = thvalue(base-1);
611 /* Check for proper usage. Merge of lua_resume() and auxresume() checks. */
612 if (co->status != LUA_YIELD) {
613 if (co->status > LUA_YIELD) {
614errdead:
615 setsvalue(L, base-1, luaS_newliteral(L, "cannot resume dead coroutine"));
616 goto err;
617 } else if (co->ci != co->base_ci) {
618 setsvalue(L, base-1,
619 luaS_newliteral(L, "cannot resume non-suspended coroutine"));
620 goto err;
621 } else if (co->base == co->top) {
622 goto errdead;
623 }
624 }
625 {
626 ptrdiff_t ndelta = (char *)L->top - (char *)base;
627 int nargs = ndelta/sizeof(TValue); /* Compute nargs. */
628 int status;
629 if ((char *)co->stack_last-(char *)co->top <= ndelta) {
630 co->ci->top = (StkId)(((char *)co->top) + ndelta); /* Ok before grow. */
631 luaD_growstack(co, nargs); /* Grow thread stack. */
632 }
633 /* Copy args. */
634 co->top = (StkId)(((char *)co->top) + ndelta);
635 { StkId t = co->top, f = L->top; while (f > base) setobj2s(co, --t, --f); }
636 L->top = base;
637 status = luaCOCO_resume(co, nargs); /* Resume Coco thread. */
638 if (status == 0 || status == LUA_YIELD) { /* Ok. */
639 StkId f;
640 if (nresults == 0) return NULL;
641 if (nresults == -1) {
642 luaD_checkstack(L, co->top - co->base); /* Grow own stack. */
643 }
644 base = L->top - 2;
645 setbvalue(base++, 1); /* true */
646 /* Copy results. Fill unused result slots with nil. */
647 f = co->base;
648 while (--nresults != 0 && f < co->top) setobj2s(L, base++, f++);
649 while (nresults-- > 0) setnilvalue(base++);
650 co->top = co->base;
651 return base;
652 } else { /* Error. */
653 base = L->top;
654 setobj2s(L, base-1, co->top-1); /* Copy error object. */
655err:
656 setbvalue(base-2, 0); /* false */
657 nresults -= 2;
658 while (--nresults >= 0) setnilvalue(base+nresults); /* Fill results. */
659 return base;
660 }
661 }
662}
663
664static void jit_inline_coroutine(jit_State *J, jit_InlineInfo *ii)
665{
666 int arg = ii->func+1;
667 int res = ii->res;
668 int i;
669 switch (JIT_IH_IDX(ii->hidx)) {
670 case JIT_IH_COROUTINE_YIELD:
671 dasm_put(Dst, 775, ((int)&LHASCOCO((lua_State *)0)), Dt1(->savedpc), (ptrdiff_t)(J->nextins), arg*sizeof(TValue));
672 if (ii->nargs >= 0) { /* Previous op was not open and did not set TOP. */
673 dasm_put(Dst, 791, Dt2([ii->nargs]));
674 }
675 dasm_put(Dst, 795, Dt1(->base), Dt1(->top), (ptrdiff_t)(luaCOCO_yield), Dt1(->base), Dt1(->top));
676 jit_assert(ii->nresults >= 0 && ii->nresults <= EXTRA_STACK);
677 for (i = 0; i < ii->nresults; i++) {
678 dasm_put(Dst, 813, Dt3([i].tt));
679 if (J->flags & JIT_F_CPU_SSE2) {
680 dasm_put(Dst, 821, Dt2([arg+i].tt), Dt2([arg+i].value), Dt2([res+i].tt), Dt2([res+i].value));
681 } else {
682 dasm_put(Dst, 839, Dt2([arg+i].value), Dt2([arg+i].value.na[1]), Dt2([arg+i].tt), Dt2([res+i].value), Dt2([res+i].value.na[1]), Dt2([res+i].tt));
683 }
684 }
685 ii->nargs = -1; /* Force restore of L->top. */
686 break;
687 case JIT_IH_COROUTINE_RESUME:
688 jit_assert(ii->nargs != 0 && ii->res == ii->func);
689 dasm_put(Dst, 787, (arg+1)*sizeof(TValue));
690 if (ii->nargs >= 0) { /* Previous op was not open and did not set TOP. */
691 dasm_put(Dst, 791, Dt2([ii->nargs-1]));
692 } else {
693 dasm_put(Dst, 858);
694 }
695 dasm_put(Dst, 865, Dt2([-1].tt), Dt2([-1].value), ((int)&LHASCOCO((lua_State *)0)), Dt1(->savedpc), (ptrdiff_t)(J->nextins), Dt1(->top), ii->nresults, (ptrdiff_t)(jit_coroutine_resume), Dt1(->base));
696 if (ii->nresults == -1) {
697 dasm_put(Dst, 909);
698 }
699 ii->nargs = -1; /* Force restore of L->top. */
700 break;
701 default:
702 jit_assert(0);
703 break;
704 }
705}
706
707#endif /* COCO_DISABLE */
708
709/* ------------------------------------------------------------------------ */
710
711static void jit_inline_string(jit_State *J, jit_InlineInfo *ii)
712{
713 int arg = ii->func+1;
714 int res = ii->res;
715 switch (JIT_IH_IDX(ii->hidx)) {
716 case JIT_IH_STRING_LEN:
717 dasm_put(Dst, 912, Dt2([arg].tt), Dt2([arg].value), DtB(->tsv.len), Dt2([res].tt), Dt2([res].value));
718 break;
719 case JIT_IH_STRING_SUB:
720 /* TODO: inline numeric constants with help from the optimizer. */
721 /* But this would save only another 15-20% in a trivial loop. */
722 jit_assert(ii->nargs >= 2); /* Open op caveat is ok, too. */
723 if (ii->nargs > 2) {
724 dasm_put(Dst, 937, Dt2([arg]), Dt2([res].value), Dt2([res].tt));
725 } else {
726 dasm_put(Dst, 954, Dt2([arg]), Dt2([res].value), Dt2([res].tt));
727 }
728 break;
729 case JIT_IH_STRING_CHAR:
730 dasm_put(Dst, 971, Dt2([arg].tt), Dt1(->env), Dt2([arg].value), (ptrdiff_t)(luaS_newlstr), Dt2([res].value), Dt2([res].tt));
731 break;
732 default:
733 jit_assert(0);
734 break;
735 }
736
737}
738
739/* ------------------------------------------------------------------------ */
740
741/* Helper functions for inlined calls to table.*. */
742static void jit_table_insert(lua_State *L, TValue *arg)
743{
744 setobj2t(L, luaH_setnum(L, hvalue(arg), luaH_getn(hvalue(arg))+1), arg+1);
745 luaC_barriert(L, hvalue(arg), arg+1);
746}
747
748static TValue *jit_table_remove(lua_State *L, TValue *arg, TValue *res)
749{
750 int n = luaH_getn(hvalue(arg));
751 if (n == 0) {
752 setnilvalue(res); /* For the nresults == 1 case. Harmless otherwise. */
753 return res; /* For the nresults == -1 case. */
754 } else {
755 TValue *val = luaH_setnum(L, hvalue(arg), n);
756 setobj2s(L, res, val);
757 setnilvalue(val);
758 return res+1; /* For the nresults == -1 case. */
759 }
760}
761
762static void jit_inline_table(jit_State *J, jit_InlineInfo *ii)
763{
764 int arg = ii->func+1;
765 int res = ii->res;
766 dasm_put(Dst, 1250, Dt2([arg].tt));
767 switch (JIT_IH_IDX(ii->hidx)) {
768 case JIT_IH_TABLE_INSERT:
769 dasm_put(Dst, 1259, Dt2([arg]), (ptrdiff_t)(jit_table_insert));
770 break;
771 case JIT_IH_TABLE_REMOVE:
772 dasm_put(Dst, 1272, Dt2([arg]), Dt2([res]), (ptrdiff_t)(jit_table_remove));
773 if (ii->nresults == -1) {
774 ii->xnresults = -1;
775 dasm_put(Dst, 909);
776 }
777 break;
778 case JIT_IH_TABLE_GETN:
779 dasm_put(Dst, 1292, Dt2([arg].value), (ptrdiff_t)(luaH_getn), Dt2([res].value), Dt2([res].tt));
780 break;
781 default:
782 jit_assert(0);
783 break;
784 }
785}
786
787/* ------------------------------------------------------------------------ */
788
789/* This typedef must match the libm function signature. */
790/* Serves as a check against wrong lua_Number or wrong calling conventions. */
791typedef lua_Number (*mathfunc_11)(lua_Number);
792
793/* Partially inlined math functions. */
794/* CHECK: must match with jit_hints.h and jit.opt_lib. */
795static const mathfunc_11 jit_mathfuncs_11[JIT_IH_MATH_SIN] = {
796 log, log10, exp, sinh, cosh, tanh, asin, acos, atan
797};
798
799/* FPU control words for ceil and floor (exceptions masked, full precision). */
800static const unsigned short jit_fpucw[2] = { 0x0b7f, 0x077f };
801
802static void jit_inline_math(jit_State *J, jit_InlineInfo *ii)
803{
804 int arg = ii->func+1;
805 int res = ii->res;
806 int idx = JIT_IH_IDX(ii->hidx);
807
808 if (idx < JIT_IH_MATH__21) {
809 dasm_put(Dst, 1317, Dt2([arg].tt), Dt2([arg].value));
810 } else {
811 jit_assert(idx < JIT_IH_MATH__LAST);
812 dasm_put(Dst, 1329, Dt2([arg].tt), Dt2([arg+1].tt));
813 }
814 switch (idx) {
815 /* We ignore sin/cos/tan range overflows (2^63 rad) just like -ffast-math. */
816 case JIT_IH_MATH_SIN:
817 dasm_put(Dst, 1347);
818 break;
819 case JIT_IH_MATH_COS:
820 dasm_put(Dst, 1351);
821 break;
822 case JIT_IH_MATH_TAN:
823 dasm_put(Dst, 1355);
824 break;
825 case JIT_IH_MATH_CEIL:
826 case JIT_IH_MATH_FLOOR:
827 dasm_put(Dst, 1361, (ptrdiff_t)&jit_fpucw[idx-JIT_IH_MATH_CEIL]);
828 break;
829 case JIT_IH_MATH_ABS:
830 dasm_put(Dst, 1374);
831 break;
832 case JIT_IH_MATH_SQRT:
833 dasm_put(Dst, 1377);
834 break;
835 case JIT_IH_MATH_FMOD:
836 dasm_put(Dst, 1381, Dt2([arg+1].value), Dt2([arg].value));
837 break;
838 case JIT_IH_MATH_ATAN2:
839 dasm_put(Dst, 1402, Dt2([arg].value), Dt2([arg+1].value));
840 break;
841 default:
842 dasm_put(Dst, 1412, (ptrdiff_t)(jit_mathfuncs_11[idx]));
843 break;
844 }
845 dasm_put(Dst, 926, Dt2([res].tt), Dt2([res].value));
846}
847
848/* ------------------------------------------------------------------------ */
849
850/* Try to inline a CALL or TAILCALL instruction. */
851static int jit_inline_call(jit_State *J, int func, int nargs, int nresults)
852{
853 const TValue *callable = hint_get(J, TYPE); /* TYPE hint = callable. */
854 int cltype = ttype(callable);
855 const TValue *oidx;
856 jit_InlineInfo ii;
857 int idx;
858
859 if (cltype != LUA_TFUNCTION) goto fail;
860 if (J->flags & JIT_F_DEBUG) goto fail; /* DWIM. */
861
862 oidx = hint_get(J, INLINE); /* INLINE hint = library/function index. */
863 if (!ttisnumber(oidx)) goto fail;
864
865 ii.hidx = (int)nvalue(oidx);
866 idx = JIT_IH_IDX(ii.hidx);
867
868 if (nresults == -2) { /* Tailcall. */
869 /* Tailcalls from vararg functions don't work with BASE[-1]. */
870 if (J->pt->is_vararg) goto fail; /* So forget about this rare case. */
871 ii.res = -1; /* Careful: 2nd result overlaps 1st stack slot. */
872 ii.nresults = -1;
873 } else {
874 ii.res = func;
875 ii.nresults = nresults;
876 }
877 ii.func = func;
878 ii.nargs = nargs;
879 ii.xnargs = ii.xnresults = 1; /* Default: 1 arg, 1 result. */
880
881 /* Check for the currently supported cases. */
882 switch (JIT_IH_LIB(ii.hidx)) {
883 case JIT_IHLIB_BASE:
884 switch (idx) {
885 case JIT_IH_BASE_PAIRS:
886 case JIT_IH_BASE_IPAIRS:
887 if (nresults == -2) goto fail; /* Not useful for tailcalls. */
888 ii.xnresults = 3;
889 goto check;
890 }
891 break;
892#ifndef COCO_DISABLE
893 case JIT_IHLIB_COROUTINE:
894 switch (idx) {
895 case JIT_IH_COROUTINE_YIELD:
896 /* Only support common cases: no tailcalls, low number of results. */
897 if (nresults < 0 || nresults > EXTRA_STACK) goto fail;
898 ii.xnargs = ii.xnresults = -1;
899 goto ok; /* Anything else is ok. */
900 case JIT_IH_COROUTINE_RESUME:
901 /* Only support common cases: no tailcalls, not with 0 args (error). */
902 if (nresults == -2 || nargs == 0) goto fail;
903 ii.xnargs = ii.xnresults = -1;
904 goto ok; /* Anything else is ok. */
905 }
906 break;
907#endif
908 case JIT_IHLIB_STRING:
909 switch (idx) {
910 case JIT_IH_STRING_LEN:
911 goto check;
912 case JIT_IH_STRING_SUB:
913 if (nargs < 2) goto fail; /* No support for open calls, too. */
914 goto ok; /* 2 or more args are ok. */
915 case JIT_IH_STRING_CHAR:
916 goto check; /* Only single arg supported. */
917 }
918 break;
919 case JIT_IHLIB_TABLE:
920 switch (idx) {
921 case JIT_IH_TABLE_INSERT:
922 ii.xnargs = 2;
923 goto check; /* Only push (append) supported. */
924 case JIT_IH_TABLE_REMOVE:
925 goto check; /* Only pop supported. */
926 case JIT_IH_TABLE_GETN:
927 goto check;
928 }
929 break;
930 case JIT_IHLIB_MATH:
931 if (idx >= JIT_IH_MATH__LAST) goto fail;
932 if (idx >= JIT_IH_MATH__21) ii.xnargs = 2;
933 goto check;
934 }
935fail:
936 return cltype; /* Call could not be inlined. Return type of callable. */
937
938check:
939 if (nargs != ii.xnargs && nargs != -1) goto fail;
940 /* The optimizer already checks the number of results (avoid setnil). */
941
942ok: /* Whew, all checks done. Go for it! */
943
944 /* Start with the common leadin for inlined calls. */
945 jit_deopt_target(J, nargs);
946 dasm_put(Dst, 1418, Dt2([func].tt), Dt2([func].value), (ptrdiff_t)(clvalue(callable)));
947 if (nargs == -1 && ii.xnargs >= 0) {
948 dasm_put(Dst, 1435, Dt2([func+1+ii.xnargs]));
949 }
950
951 /* Now inline the function itself. */
952 switch (JIT_IH_LIB(ii.hidx)) {
953 case JIT_IHLIB_BASE: jit_inline_base(J, &ii); break;
954#ifndef COCO_DISABLE
955 case JIT_IHLIB_COROUTINE: jit_inline_coroutine(J, &ii); break;
956#endif
957 case JIT_IHLIB_STRING: jit_inline_string(J, &ii); break;
958 case JIT_IHLIB_TABLE: jit_inline_table(J, &ii); break;
959 case JIT_IHLIB_MATH: jit_inline_math(J, &ii); break;
960 default: jit_assert(0); break;
961 }
962
963 /* And add the common leadout for inlined calls. */
964 if (ii.nresults == -1) {
965 if (ii.xnresults >= 0) {
966 dasm_put(Dst, 791, Dt2([ii.res+ii.xnresults]));
967 }
968 } else if (ii.nargs == -1) { /* Restore L->top only if needed. */
969 dasm_put(Dst, 1445, Dt2([J->pt->maxstacksize]), Dt1(->top));
970 }
971
972 if (nresults == -2) { /* Results are in place. Add return for tailcalls. */
973 dasm_put(Dst, 1452, sizeof(TValue), Dt1(->ci), sizeof(CallInfo));
974 }
975
976 return -1; /* Success, call has been inlined. */
977}
978
979/* ------------------------------------------------------------------------ */
980
981/* Helper function for inlined iterator code. Paraphrased from luaH_next. */
982/* TODO: GCC has trouble optimizing this. */
983static int jit_table_next(lua_State *L, TValue *ra)
984{
985 Table *t = hvalue(&ra[TFOR_TAB]);
986 int i = ra[TFOR_CTL].value.b; /* Hidden control variable. */
987 for (; i < t->sizearray; i++) { /* First the array part. */
988 if (!ttisnil(&t->array[i])) {
989 setnvalue(&ra[TFOR_KEY], cast_num(i+1));
990 setobj2s(L, &ra[TFOR_VAL], &t->array[i]);
991 ra[TFOR_CTL].value.b = i+1;
992 return 1;
993 }
994 }
995 for (i -= t->sizearray; i < sizenode(t); i++) { /* Then the hash part. */
996 if (!ttisnil(gval(gnode(t, i)))) {
997 setobj2s(L, &ra[TFOR_KEY], key2tval(gnode(t, i)));
998 setobj2s(L, &ra[TFOR_VAL], gval(gnode(t, i)));
999 ra[TFOR_CTL].value.b = i+1+t->sizearray;
1000 return 1;
1001 }
1002 }
1003 return 0; /* End of iteration. */
1004}
1005
1006/* Try to inline a TFORLOOP instruction. */
1007static int jit_inline_tforloop(jit_State *J, int ra, int nresults, int target)
1008{
1009 const TValue *oidx = hint_get(J, INLINE); /* INLINE hint = lib/func idx. */
1010 int idx;
1011
1012 if (!ttisnumber(oidx)) return 0; /* No hint: don't inline anything. */
1013 idx = (int)nvalue(oidx);
1014 if (J->flags & JIT_F_DEBUG) return 0; /* DWIM. */
1015
1016 switch (idx) {
1017 case JIT_IH_MKIDX(JIT_IHLIB_BASE, JIT_IH_BASE_PAIRS):
1018 dasm_put(Dst, 1465, Dt2([ra]), (ptrdiff_t)(jit_table_next), target);
1019 return 1; /* Success, iterator has been inlined. */
1020 case JIT_IH_MKIDX(JIT_IHLIB_BASE, JIT_IH_BASE_IPAIRS):
1021 dasm_put(Dst, 1483, Dt2([ra+TFOR_CTL].value), Dt2([ra+TFOR_TAB].value), Dt2([ra+TFOR_CTL].value), (ptrdiff_t)(luaH_getnum), Dt7(->tt), Dt2([ra+TFOR_CTL].value), Dt2([ra+TFOR_KEY].tt), Dt2([ra+TFOR_KEY].value), Dt7(->value), Dt7(->value.na[1]), Dt2([ra+TFOR_VAL].tt), Dt2([ra+TFOR_VAL].value), Dt2([ra+TFOR_VAL].value.na[1]), target);
1022 return 1; /* Success, iterator has been inlined. */
1023 }
1024
1025 return 0; /* No support for inlining any other iterators. */
1026}
1027
1028/* ------------------------------------------------------------------------ */
1029
1030
1031
1032#ifdef LUA_COMPAT_VARARG
1033static void jit_vararg_table(lua_State *L)
1034{
1035 Table *tab;
1036 StkId base, func;
1037 int i, num, numparams;
1038 luaC_checkGC(L);
1039 base = L->base;
1040 func = L->ci->func;
1041 numparams = clvalue(func)->l.p->numparams;
1042 num = base - func - numparams - 1;
1043 tab = luaH_new(L, num, 1);
1044 for (i = 0; i < num; i++)
1045 setobj2n(L, luaH_setnum(L, tab, i+1), base - num + i);
1046 setnvalue(luaH_setstr(L, tab, luaS_newliteral(L, "n")), (lua_Number)num);
1047 sethvalue(L, base + numparams, tab);
1048}
1049#endif
1050
1051/* Encode JIT function prologue. */
1052static void jit_prologue(jit_State *J)
1053{
1054 Proto *pt = J->pt;
1055 int numparams = pt->numparams;
1056 int stacksize = pt->maxstacksize;
1057
1058 dasm_put(Dst, 1544, Dt3([stacksize]), Dt1(->stack_last), Dt1(->end_ci), Dt4([1]), Dt4(->func), sizeof(TValue), Dt1(->ci));
1059
1060 if (numparams > 0) {
1061 dasm_put(Dst, 1580, Dt2([numparams]));
1062 }
1063
1064 if (!pt->is_vararg) { /* Fixarg function. */
1065 /* Must cap L->top at L->base+numparams because 1st LOADNIL is omitted. */
1066 if (numparams == 0) {
1067 dasm_put(Dst, 1586);
1068 } else if (J->flags & JIT_F_CPU_CMOV) {
1069 dasm_put(Dst, 1589);
1070 } else {
1071 dasm_put(Dst, 1594);
1072 }
1073 dasm_put(Dst, 1603, Dt2([stacksize]), Dt4(->tailcalls), Dt4(->top), Dt1(->top), Dt1(->base), Dt4(->base));
1074 } else { /* Vararg function. */
1075 int i;
1076 if (numparams > 0) {
1077 dasm_put(Dst, 1622);
1078 dasm_put(Dst, 1630, Dt3(->tt), sizeof(TValue));
1079 }
1080 dasm_put(Dst, 1649, Dt1(->base), Dt4(->base), Dt4(->tailcalls));
1081 for (i = 0; i < numparams; i++) { /* Move/clear fixargs. */
1082 if (J->flags & JIT_F_CPU_SSE2) {
1083 dasm_put(Dst, 1659, Dt2([i].tt), Dt2([i].value), Dt3([i].tt), Dt3([i].value));
1084 } else {
1085 dasm_put(Dst, 1677, Dt2([i].value), Dt2([i].value.na[1]), Dt3([i].value), Dt2([i].tt), Dt3([i].value.na[1]), Dt3([i].tt));
1086 }
1087 dasm_put(Dst, 854, Dt2([i].tt));
1088 }
1089 if (numparams > 0) {
1090 dasm_put(Dst, 332, Dt1(->ci));
1091 }
1092 dasm_put(Dst, 1696, Dt2([stacksize]), Dt2([numparams]), Dt4(->top), Dt1(->top));
1093 stacksize -= numparams; /* Fixargs are already cleared. */
1094 }
1095
1096 /* Clear undefined args and all vars. Still assumes eax = LUA_TNIL = 0. */
1097 /* Note: cannot clear only args because L->top has grown. */
1098 if (stacksize <= EXTRA_STACK) { /* Loopless clear. May use EXTRA_STACK. */
1099 int i;
1100 for (i = 0; i < stacksize; i++) {
1101 dasm_put(Dst, 1712, Dt3([i].tt));
1102 }
1103 } else { /* Standard loop. */
1104 dasm_put(Dst, 1716, Dt3([0].tt), Dt3([1].tt), 2*sizeof(TValue));
1105 }
1106
1107#ifdef LUA_COMPAT_VARARG
1108 if (pt->is_vararg & VARARG_NEEDSARG) {
1109 dasm_put(Dst, 1734, (ptrdiff_t)(jit_vararg_table));
1110 }
1111#endif
1112
1113 /* Call hook check. */
1114 if (J->flags & JIT_F_DEBUG_CALL) {
1115 dasm_put(Dst, 1740, Dt1(->hookmask), LUA_MASKCALL);
1116
1117 }
1118}
1119
1120/* Check if we can combine 'return const'. */
1121static int jit_return_k(jit_State *J)
1122{
1123 if (!J->combine) return 0; /* COMBINE hint set? */
1124 /* May need to close open upvalues. */
1125 if (!fhint_isset(J, NOCLOSE)) {
1126 dasm_put(Dst, 1820, (ptrdiff_t)(luaF_close));
1127 }
1128 if (!J->pt->is_vararg) { /* Fixarg function. */
1129 dasm_put(Dst, 1830, Dt1(->ci), sizeof(CallInfo), sizeof(TValue));
1130 } else { /* Vararg function. */
1131 dasm_put(Dst, 1844, Dt1(->ci), Dt4(->func), sizeof(CallInfo), Dt1(->ci), Dt2([1]));
1132 }
1133 jit_assert(J->combine == 1); /* Required to skip next RETURN instruction. */
1134 return 1;
1135}
1136
1137static void jit_op_return(jit_State *J, int rbase, int nresults)
1138{
1139 /* Return hook check. */
1140 if (J->flags & JIT_F_DEBUG_CALL) {
1141 if (nresults < 0 && !(J->flags & JIT_F_DEBUG_INS)) {
1142 dasm_put(Dst, 594, Dt1(->top));
1143 }
1144 dasm_put(Dst, 1863, Dt1(->hookmask), LUA_MASKRET);
1145 if (J->flags & JIT_F_DEBUG_INS) {
1146 dasm_put(Dst, 1878, Dt1(->savedpc));
1147 }
1148
1149 }
1150
1151 /* May need to close open upvalues. */
1152 if (!fhint_isset(J, NOCLOSE)) {
1153 dasm_put(Dst, 1820, (ptrdiff_t)(luaF_close));
1154 }
1155
1156 /* Previous op was open: 'return f()' or 'return ...' */
1157 if (nresults < 0) {
1158 dasm_put(Dst, 332, Dt1(->ci));
1159 if (rbase) {
1160 dasm_put(Dst, 787, rbase*sizeof(TValue));
1161 }
1162 dasm_put(Dst, 1933, Dt4(->func), Dt4(->func), sizeof(CallInfo), Dt1(->ci));
1163 return;
1164 }
1165
1166 if (!J->pt->is_vararg) { /* Fixarg function, nresults >= 0. */
1167 int i;
1168 dasm_put(Dst, 1980, Dt1(->ci), sizeof(CallInfo), sizeof(TValue));
1169 for (i = 0; i < nresults; i++) {
1170 if (J->flags & JIT_F_CPU_SSE2) {
1171 dasm_put(Dst, 821, Dt2([rbase+i+1].tt), Dt2([rbase+i+1].value), Dt2([i].tt), Dt2([i].value));
1172 } else {
1173 dasm_put(Dst, 839, Dt2([rbase+i+1].value), Dt2([rbase+i+1].value.na[1]), Dt2([rbase+i+1].tt), Dt2([i].value), Dt2([i].value.na[1]), Dt2([i].tt));
1174 }
1175 }
1176 dasm_put(Dst, 1989, Dt2([nresults]));
1177 } else { /* Vararg function, nresults >= 0. */
1178 int i;
1179 dasm_put(Dst, 1997, Dt1(->ci), Dt4(->func), sizeof(CallInfo), Dt1(->ci));
1180 for (i = 0; i < nresults; i++) {
1181 if (J->flags & JIT_F_CPU_SSE2) {
1182 dasm_put(Dst, 1659, Dt2([rbase+i].tt), Dt2([rbase+i].value), Dt3([i].tt), Dt3([i].value));
1183 } else {
1184 dasm_put(Dst, 2010, Dt2([rbase+i].value), Dt2([rbase+i].value.na[1]), Dt2([rbase+i].tt), Dt3([i].value), Dt3([i].value.na[1]), Dt3([i].tt));
1185 }
1186 }
1187 dasm_put(Dst, 2029);
1188 if (nresults) {
1189 dasm_put(Dst, 2036, nresults*sizeof(TValue));
1190 }
1191 dasm_put(Dst, 32);
1192 }
1193}
1194
1195static void jit_op_call(jit_State *J, int func, int nargs, int nresults)
1196{
1197 int cltype = jit_inline_call(J, func, nargs, nresults);
1198 if (cltype < 0) return; /* Inlined? */
1199
1200 if (func) {
1201 dasm_put(Dst, 787, func*sizeof(TValue));
1202 }
1203 dasm_put(Dst, 2040, Dt1(->ci), Dt2([0].tt));
1204 if (nargs >= 0) { /* Previous op was not open and did not set TOP. */
1205 dasm_put(Dst, 791, Dt2([1+nargs]));
1206 }
1207 dasm_put(Dst, 2048, Dt2(->value), (ptrdiff_t)(J->nextins), Dt4(->savedpc));
1208 if (cltype == LUA_TFUNCTION) {
1209 if (nargs == -1) {
1210 dasm_put(Dst, 2057);
1211 } else {
1212 dasm_put(Dst, 2062);
1213 }
1214 } else {
1215 dasm_put(Dst, 2067);
1216
1217 }
1218 dasm_put(Dst, 2116, Dt5(->jit_gate));
1219 if (func) {
1220 dasm_put(Dst, 1984, func*sizeof(TValue));
1221 }
1222 dasm_put(Dst, 2121, Dt1(->base));
1223
1224 /* Clear undefined results TOP <= o < func+nresults. */
1225 if (nresults > 0) {
1226 dasm_put(Dst, 2125);
1227 if (nresults <= EXTRA_STACK) { /* Loopless clear. May use EXTRA_STACK. */
1228 int i;
1229 for (i = 0; i < nresults; i++) {
1230 dasm_put(Dst, 1712, Dt3([i].tt));
1231 }
1232 } else { /* Standard loop. TODO: move to .tail? */
1233 dasm_put(Dst, 2128, Dt2([func+nresults]), Dt3([0].tt), Dt3([1].tt), 2*sizeof(TValue));
1234 }
1235 }
1236
1237 if (nresults >= 0) { /* Not an open ins. Restore L->top. */
1238 dasm_put(Dst, 1445, Dt2([J->pt->maxstacksize]), Dt1(->top));
1239 } /* Otherwise keep TOP for next instruction. */
1240}
1241
1242static void jit_op_tailcall(jit_State *J, int func, int nargs)
1243{
1244 int cltype;
1245
1246 if (!fhint_isset(J, NOCLOSE)) { /* May need to close open upvalues. */
1247 dasm_put(Dst, 1820, (ptrdiff_t)(luaF_close));
1248 }
1249
1250 cltype = jit_inline_call(J, func, nargs, -2);
1251 if (cltype < 0) goto finish; /* Inlined? */
1252
1253 if (cltype == LUA_TFUNCTION) {
1254 jit_deopt_target(J, nargs);
1255 dasm_put(Dst, 2149, Dt2([func].tt));
1256 } else {
1257 dasm_put(Dst, 2158, Dt2([func].tt));
1258 dasm_put(Dst, 2168);
1259 if (func) {
1260 dasm_put(Dst, 787, func*sizeof(TValue));
1261 }
1262 if (nargs >= 0) {
1263 dasm_put(Dst, 791, Dt2([1+nargs]));
1264 }
1265 dasm_put(Dst, 2171, (ptrdiff_t)(J->nextins));
1266
1267 }
1268
1269 if (nargs >= 0) { /* Previous op was not open and did not set TOP. */
1270 int i;
1271 /* Relocate [BASE+func, BASE+func+nargs] -> [ci->func, ci->func+nargs]. */
1272 /* TODO: loop for large nargs? */
1273 if (!J->pt->is_vararg) { /* Fixarg function. */
1274 dasm_put(Dst, 2241, Dt2([func].value));
1275 for (i = 0; i < nargs; i++) {
1276 if (J->flags & JIT_F_CPU_SSE2) {
1277 dasm_put(Dst, 821, Dt2([func+1+i].tt), Dt2([func+1+i].value), Dt2([i].tt), Dt2([i].value));
1278 } else {
1279 dasm_put(Dst, 2245, Dt2([func+1+i].value), Dt2([func+1+i].value.na[1]), Dt2([i].value), Dt2([func+1+i].tt), Dt2([i].value.na[1]), Dt2([i].tt));
1280 }
1281 }
1282 dasm_put(Dst, 2264, Dt2([nargs]), sizeof(TValue), Dt1(->ci), Dt2(->value));
1283 } else { /* Vararg function. */
1284 dasm_put(Dst, 2278, Dt1(->ci), Dt2([func]), Dt4(->func), Dt3(->value), Dt2(->value));
1285 for (i = 0; i < nargs; i++) {
1286 if (J->flags & JIT_F_CPU_SSE2) {
1287 dasm_put(Dst, 2294, Dt3([i+1].tt), Dt3([i+1].value), Dt2([i+1].tt), Dt2([i+1].value));
1288 } else {
1289 dasm_put(Dst, 2312, Dt3([i+1].value), Dt3([i+1].value.na[1]), Dt2([i+1].value), Dt3([i+1].tt), Dt2([i+1].value.na[1]), Dt2([i+1].tt));
1290 }
1291 }
1292 dasm_put(Dst, 2331, Dt2([1+nargs]), Dt2(->value));
1293 }
1294 } else { /* Previous op was open and set TOP. */
1295 dasm_put(Dst, 332, Dt1(->ci));
1296 if (func) {
1297 dasm_put(Dst, 787, func*sizeof(TValue));
1298 }
1299 dasm_put(Dst, 2338, Dt4(->func), Dt4(->func), Dt2(->value));
1300 }
1301 dasm_put(Dst, 2230, sizeof(CallInfo), Dt5(->jit_gate));
1302
1303finish:
1304 J->combine++; /* Combine with following return instruction. */
1305}
1306
1307/* ------------------------------------------------------------------------ */
1308
1309static void jit_op_move(jit_State *J, int dest, int src)
1310{
1311 if (J->flags & JIT_F_CPU_SSE2) {
1312 dasm_put(Dst, 821, Dt2([src].tt), Dt2([src].value), Dt2([dest].tt), Dt2([dest].value));
1313 } else {
1314 dasm_put(Dst, 839, Dt2([src].value), Dt2([src].value.na[1]), Dt2([src].tt), Dt2([dest].value), Dt2([dest].value.na[1]), Dt2([dest].tt));
1315 }
1316}
1317
1318static void jit_op_loadk(jit_State *J, int dest, int kidx)
1319{
1320 const TValue *kk = &J->pt->k[kidx];
1321 int rk = jit_return_k(J);
1322 if (rk) dest = 0;
1323 switch (ttype(kk)) {
1324 case 0:
1325 dasm_put(Dst, 2369, Dt2([dest].tt));
1326 break;
1327 case 1:
1328 if (bvalue(kk)) { /* true */
1329 dasm_put(Dst, 2377, Dt2([dest].value), Dt2([dest].tt));
1330 } else { /* false */
1331 dasm_put(Dst, 2389, Dt2([dest].value), Dt2([dest].tt));
1332 }
1333 break;
1334 case 3: {
1335 if ((&(kk)->value)->n == (lua_Number)0) {
1336 dasm_put(Dst, 2404);
1337 } else if ((&(kk)->value)->n == (lua_Number)1) {
1338 dasm_put(Dst, 2408);
1339 } else {
1340 dasm_put(Dst, 2411, &(kk)->value);
1341 }
1342 dasm_put(Dst, 1306, Dt2([dest].value), Dt2([dest].tt));
1343 break;
1344 }
1345 case 4:
1346 dasm_put(Dst, 2415, Dt2([dest].value), (ptrdiff_t)(gcvalue(kk)), Dt2([dest].tt));
1347 break;
1348 default: lua_assert(0); break;
1349 }
1350 if (rk) {
1351 dasm_put(Dst, 32);
1352 }
1353}
1354
1355static void jit_op_loadnil(jit_State *J, int first, int last)
1356{
1357 int idx, num = last - first + 1;
1358 int rk = jit_return_k(J);
1359 dasm_put(Dst, 2125);
1360 if (rk) {
1361 dasm_put(Dst, 2427, Dt2([0].tt));
1362 } else if (num <= 8) {
1363 for (idx = first; idx <= last; idx++) {
1364 dasm_put(Dst, 854, Dt2([idx].tt));
1365 }
1366 } else {
1367 dasm_put(Dst, 2432, Dt2([first].tt), Dt2([last].tt), sizeof(TValue));
1368 }
1369}
1370
1371static void jit_op_loadbool(jit_State *J, int dest, int b, int dojump)
1372{
1373 int rk = jit_return_k(J);
1374 if (rk) dest = 0;
1375 if (b) { /* true */
1376 dasm_put(Dst, 2377, Dt2([dest].value), Dt2([dest].tt));
1377 } else { /* false */
1378 dasm_put(Dst, 2389, Dt2([dest].value), Dt2([dest].tt));
1379 }
1380 if (rk) {
1381 dasm_put(Dst, 32);
1382 } else if (dojump) {
1383 const TValue *h = hint_getpc(J, COMBINE, J->nextpc);
1384 if (!(ttisboolean(h) && bvalue(h) == 0)) { /* Avoid jmp around dead ins. */
1385 dasm_put(Dst, 665, J->nextpc+1);
1386 }
1387 }
1388}
1389
1390/* ------------------------------------------------------------------------ */
1391
1392static void jit_op_getupval(jit_State *J, int dest, int uvidx)
1393{
1394 if (!J->pt->is_vararg) {
1395 dasm_put(Dst, 2241, Dt2([-1].value));
1396 } else {
1397 dasm_put(Dst, 2452, Dt1(->ci), Dt4(->func), Dt3(->value));
1398 }
1399 dasm_put(Dst, 2462, Dt5(->upvals[uvidx]), DtF(->v));
1400 if (J->flags & JIT_F_CPU_SSE2) {
1401 dasm_put(Dst, 2469, Dt3([0].tt), Dt3([0].value), Dt2([dest].tt), Dt2([dest].value));
1402 } else {
1403 dasm_put(Dst, 2487, Dt3([0].value), Dt3([0].value.na[1]), Dt3([0].tt), Dt2([dest].value), Dt2([dest].value.na[1]), Dt2([dest].tt));
1404 }
1405}
1406
1407static void jit_op_setupval(jit_State *J, int src, int uvidx)
1408{
1409 if (!J->pt->is_vararg) {
1410 dasm_put(Dst, 2241, Dt2([-1].value));
1411 } else {
1412 dasm_put(Dst, 2452, Dt1(->ci), Dt4(->func), Dt3(->value));
1413 }
1414 dasm_put(Dst, 2506, Dt5(->upvals[uvidx]), DtF(->v), Dt2([src].tt), Dt2([src].value), Dt3(->tt), Dt2([src].value.na[1]), Dt3(->value), Dt3(->value.na[1]));
1415 dasm_put(Dst, 2542, DtA(->gch.marked), WHITEBITS, DtF(->marked), bitmask(BLACKBIT));
1416
1417}
1418
1419/* ------------------------------------------------------------------------ */
1420
1421/* Optimized table lookup routines. Enter via jsub, fallback to C. */
1422
1423/* Fallback for GETTABLE_*. Temporary key is in L->env. */
1424static void jit_gettable_fb(lua_State *L, Table *t, StkId dest)
1425{
1426 Table *mt = t->metatable;
1427 const TValue *tm = luaH_getstr(mt, G(L)->tmname[TM_INDEX]);
1428 if (ttisnil(tm)) { /* No __index method? */
1429 mt->flags |= 1<<TM_INDEX; /* Cache this fact. */
1430 setnilvalue(dest);
1431 } else if (ttisfunction(tm)) { /* __index function? */
1432 ptrdiff_t destr = savestack(L, dest);
1433 setobj2s(L, L->top, tm);
1434 sethvalue(L, L->top+1, t);
1435 setobj2s(L, L->top+2, &L->env);
1436 luaD_checkstack(L, 3);
1437 L->top += 3;
1438 luaD_call(L, L->top - 3, 1);
1439 dest = restorestack(L, destr);
1440 L->top--;
1441 setobjs2s(L, dest, L->top);
1442 } else { /* Let luaV_gettable() continue with the __index object. */
1443 luaV_gettable(L, tm, &L->env, dest);
1444 }
1445
1446}
1447
1448/* Fallback for SETTABLE_*STR. Temporary (string) key is in L->env. */
1449static void jit_settable_fb(lua_State *L, Table *t, StkId val)
1450{
1451 Table *mt = t->metatable;
1452 const TValue *tm = luaH_getstr(mt, G(L)->tmname[TM_NEWINDEX]);
1453 if (ttisnil(tm)) { /* No __newindex method? */
1454 mt->flags |= 1<<TM_NEWINDEX; /* Cache this fact. */
1455 t->flags = 0; /* But need to clear the cache for the table itself. */
1456 setobj2t(L, luaH_setstr(L, t, rawtsvalue(&L->env)), val);
1457 luaC_barriert(L, t, val);
1458 } else if (ttisfunction(tm)) { /* __newindex function? */
1459 setobj2s(L, L->top, tm);
1460 sethvalue(L, L->top+1, t);
1461 setobj2s(L, L->top+2, &L->env);
1462 setobj2s(L, L->top+3, val);
1463 luaD_checkstack(L, 4);
1464 L->top += 4;
1465 luaD_call(L, L->top - 4, 0);
1466 } else { /* Let luaV_settable() continue with the __newindex object. */
1467 luaV_settable(L, tm, &L->env, val);
1468 }
1469
1470}
1471
1472/* ------------------------------------------------------------------------ */
1473
1474static void jit_op_newtable(jit_State *J, int dest, int lnarray, int lnhash)
1475{
1476 dasm_put(Dst, 3158, luaO_fb2int(lnarray), luaO_fb2int(lnhash), (ptrdiff_t)(luaH_new), Dt2([dest].value), Dt2([dest].tt));
1477 jit_checkGC(J);
1478}
1479
1480static void jit_op_getglobal(jit_State *J, int dest, int kidx)
1481{
1482 const TValue *kk = &J->pt->k[kidx];
1483 jit_assert(ttisstring(kk));
1484 dasm_put(Dst, 3184, (ptrdiff_t)(&kk->value.gc->ts));
1485 if (dest) {
1486 dasm_put(Dst, 787, dest*sizeof(TValue));
1487 }
1488 dasm_put(Dst, 3187);
1489}
1490
1491static void jit_op_setglobal(jit_State *J, int rval, int kidx)
1492{
1493 const TValue *kk = &J->pt->k[kidx];
1494 jit_assert(ttisstring(kk));
1495 dasm_put(Dst, 3184, (ptrdiff_t)(&kk->value.gc->ts));
1496 if (rval) {
1497 dasm_put(Dst, 787, rval*sizeof(TValue));
1498 }
1499 dasm_put(Dst, 3191);
1500}
1501
1502enum { TKEY_KSTR = -2, TKEY_STR = -1, TKEY_ANY = 0 };
1503
1504/* Optimize key lookup depending on consts or hints type. */
1505static int jit_keylookup(jit_State *J, int tab, int rkey)
1506{
1507 const TValue *tabt = hint_get(J, TYPE);
1508 const TValue *key;
1509 if (!ttistable(tabt)) return TKEY_ANY; /* Not a table? Use fallback. */
1510 key = ISK(rkey) ? &J->pt->k[INDEXK(rkey)] : hint_get(J, TYPEKEY);
1511 if (ttisstring(key)) { /* String key? */
1512 if (ISK(rkey)) {
1513 dasm_put(Dst, 3195, Dt2([tab]), (ptrdiff_t)(&key->value.gc->ts));
1514 return TKEY_KSTR; /* Const string key. */
1515 } else {
1516 dasm_put(Dst, 3201, Dt2([tab]), Dt2([rkey]));
1517 return TKEY_STR; /* Var string key. */
1518 }
1519 } else if (ttisnumber(key)) { /* Number key? */
1520 lua_Number n = nvalue(key);
1521 int k;
1522 lua_number2int(k, n);
1523 if (!(k >= 1 && k < (1 << 26) && (lua_Number)k == n))
1524 return TKEY_ANY; /* Not a proper array key? Use fallback. */
1525 if (ISK(rkey)) {
1526 dasm_put(Dst, 3208, Dt2([tab].tt), Dt2([tab].value), k, DtC(->array), DtC(->sizearray));
1527 return k; /* Const array key (>= 1). */
1528 } else {
1529 dasm_put(Dst, 3232, Dt2([tab].tt), Dt2([rkey].tt));
1530 if (J->flags & JIT_F_CPU_SSE2) {
1531 dasm_put(Dst, 3250, Dt2([rkey]), Dt2([tab].value));
1532 } else {
1533 dasm_put(Dst, 3283, Dt2([rkey].value));
1534 if (J->flags & JIT_F_CPU_CMOV) {
1535 dasm_put(Dst, 3293);
1536 } else {
1537 dasm_put(Dst, 3298);
1538 }
1539 dasm_put(Dst, 3304, Dt2([tab].value));
1540 }
1541 dasm_put(Dst, 3320, DtC(->sizearray), DtC(->array));
1542 return 1; /* Variable array key. */
1543 }
1544 }
1545 return TKEY_ANY; /* Use fallback. */
1546}
1547
1548static void jit_op_gettable(jit_State *J, int dest, int tab, int rkey)
1549{
1550 int k = jit_keylookup(J, tab, rkey);
1551 switch (k) {
1552 case TKEY_KSTR: /* Const string key. */
1553 if (dest) {
1554 dasm_put(Dst, 787, dest*sizeof(TValue));
1555 }
1556 dasm_put(Dst, 3334);
1557 break;
1558 case TKEY_STR: /* Variable string key. */
1559 if (dest) {
1560 dasm_put(Dst, 787, dest*sizeof(TValue));
1561 }
1562 dasm_put(Dst, 3338);
1563 break;
1564 case TKEY_ANY: /* Generic gettable fallback. */
1565 if (ISK(rkey)) {
1566 dasm_put(Dst, 3342, (ptrdiff_t)(&J->pt->k[INDEXK(rkey)]));
1567 } else {
1568 dasm_put(Dst, 3204, Dt2([rkey]));
1569 }
1570 dasm_put(Dst, 3345, Dt2([tab]));
1571 if (dest) {
1572 dasm_put(Dst, 787, dest*sizeof(TValue));
1573 }
1574 dasm_put(Dst, 3349, Dt1(->savedpc), (ptrdiff_t)(J->nextins), (ptrdiff_t)(luaV_gettable), Dt1(->base));
1575 break;
1576 default: /* Array key. */
1577 dasm_put(Dst, 3366, Dt7([k-1].tt));
1578 if (J->flags & JIT_F_CPU_SSE2) {
1579 dasm_put(Dst, 2674, Dt7([k-1].value), Dt2([dest].value));
1580 } else {
1581 dasm_put(Dst, 3378, Dt7([k-1].value), Dt7([k-1].value.na[1]), Dt2([dest].value), Dt2([dest].value.na[1]));
1582 }
1583 dasm_put(Dst, 3391, Dt2([dest].tt));
1584 dasm_put(Dst, 2168);
1585 if (ISK(rkey)) {
1586 dasm_put(Dst, 3398);
1587 } else {
1588 dasm_put(Dst, 3402);
1589 }
1590 dasm_put(Dst, 3406, DtC(->metatable), DtC(->flags), 1<<TM_INDEX, (ptrdiff_t)(J->nextins));
1591 break;
1592 }
1593
1594}
1595
1596static void jit_op_settable(jit_State *J, int tab, int rkey, int rval)
1597{
1598 const TValue *val = ISK(rval) ? &J->pt->k[INDEXK(rval)] : NULL;
1599 int k = jit_keylookup(J, tab, rkey);
1600 switch (k) {
1601 case TKEY_KSTR: /* Const string key. */
1602 case TKEY_STR: /* Variable string key. */
1603 if (ISK(rval)) {
1604 dasm_put(Dst, 3492, (ptrdiff_t)(val));
1605 } else {
1606 if (rval) {
1607 dasm_put(Dst, 787, rval*sizeof(TValue));
1608 }
1609 }
1610 if (k == TKEY_KSTR) {
1611 dasm_put(Dst, 3495);
1612 } else {
1613 dasm_put(Dst, 3499);
1614 }
1615 break;
1616 case TKEY_ANY: /* Generic settable fallback. */
1617 if (ISK(rkey)) {
1618 dasm_put(Dst, 3342, (ptrdiff_t)(&J->pt->k[INDEXK(rkey)]));
1619 } else {
1620 dasm_put(Dst, 3204, Dt2([rkey]));
1621 }
1622 if (ISK(rval)) {
1623 dasm_put(Dst, 3184, (ptrdiff_t)(val));
1624 } else {
1625 dasm_put(Dst, 3345, Dt2([rval]));
1626 }
1627 if (tab) {
1628 dasm_put(Dst, 787, tab*sizeof(TValue));
1629 }
1630 dasm_put(Dst, 3503, Dt1(->savedpc), (ptrdiff_t)(J->nextins), (ptrdiff_t)(luaV_settable), Dt1(->base));
1631 break;
1632 default: /* Array key. */
1633 dasm_put(Dst, 3520, Dt7([k-1].tt));
1634 dasm_put(Dst, 2168);
1635 if (ISK(rkey)) {
1636 dasm_put(Dst, 3534);
1637 } else {
1638 dasm_put(Dst, 3538);
1639 }
1640 dasm_put(Dst, 3406, DtC(->metatable), DtC(->flags), 1<<TM_NEWINDEX, (ptrdiff_t)(J->nextins));
1641 if (!ISK(rval) || iscollectable(val)) {
1642 dasm_put(Dst, 3542, DtC(->marked), bitmask(BLACKBIT));
1643 dasm_put(Dst, 3555);
1644 }
1645 if (ISK(rval)) {
1646 switch (ttype(val)) {
1647 case 0:
1648 dasm_put(Dst, 3565, Dt7([k-1].tt));
1649 break;
1650 case 1:
1651 if (bvalue(val)) { /* true */
1652 dasm_put(Dst, 3573, Dt7([k-1].value), Dt7([k-1].tt));
1653 } else { /* false */
1654 dasm_put(Dst, 3585, Dt7([k-1].value), Dt7([k-1].tt));
1655 }
1656 break;
1657 case 3: {
1658 if ((&(val)->value)->n == (lua_Number)0) {
1659 dasm_put(Dst, 2404);
1660 } else if ((&(val)->value)->n == (lua_Number)1) {
1661 dasm_put(Dst, 2408);
1662 } else {
1663 dasm_put(Dst, 2411, &(val)->value);
1664 }
1665 dasm_put(Dst, 3600, Dt7([k-1].value), Dt7([k-1].tt));
1666 break;
1667 }
1668 case 4:
1669 dasm_put(Dst, 3611, Dt7([k-1].value), (ptrdiff_t)(gcvalue(val)), Dt7([k-1].tt));
1670 break;
1671 default: lua_assert(0); break;
1672 }
1673 } else {
1674 if (J->flags & JIT_F_CPU_SSE2) {
1675 dasm_put(Dst, 2947, Dt2([rval].tt), Dt2([rval].value), Dt7([k-1].tt), Dt7([k-1].value));
1676 } else {
1677 dasm_put(Dst, 2965, Dt2([rval].value), Dt2([rval].value.na[1]), Dt2([rval].tt), Dt7([k-1].value), Dt7([k-1].value.na[1]), Dt7([k-1].tt));
1678 }
1679 }
1680 break;
1681 }
1682
1683}
1684
1685static void jit_op_self(jit_State *J, int dest, int tab, int rkey)
1686{
1687 if (J->flags & JIT_F_CPU_SSE2) {
1688 dasm_put(Dst, 821, Dt2([tab].tt), Dt2([tab].value), Dt2([dest+1].tt), Dt2([dest+1].value));
1689 } else {
1690 dasm_put(Dst, 839, Dt2([tab].value), Dt2([tab].value.na[1]), Dt2([tab].tt), Dt2([dest+1].value), Dt2([dest+1].value.na[1]), Dt2([dest+1].tt));
1691 }
1692 jit_op_gettable(J, dest, tab, rkey);
1693}
1694
1695/* ------------------------------------------------------------------------ */
1696
1697static void jit_op_setlist(jit_State *J, int ra, int num, int batch)
1698{
1699 if (batch == 0) { batch = (int)(*J->nextins); J->combine++; }
1700 batch = (batch-1)*LFIELDS_PER_FLUSH;
1701 if (num == 0) { /* Previous op was open and set TOP: {f()} or {...}. */
1702 dasm_put(Dst, 3685, Dt1(->env.value), Dt2([ra+1]), Dt2([ra].value));
1703 if (batch > 0) {
1704 dasm_put(Dst, 3709, batch);
1705 }
1706 dasm_put(Dst, 3713, DtC(->sizearray), (ptrdiff_t)(luaH_resizearray), DtC(->marked), bitmask(BLACKBIT), DtC(->array), Dt1(->env.value));
1707 dasm_put(Dst, 3752);
1708 } else { /* Set fixed number of args. */
1709 dasm_put(Dst, 3762, Dt2([ra].value), DtC(->sizearray), batch+num, DtC(->marked), bitmask(BLACKBIT), DtC(->array), Dt2([ra+1+num]));
1710 dasm_put(Dst, 3792, batch+num, (ptrdiff_t)(luaH_resizearray));
1711 }
1712 if (batch > 0) {
1713 dasm_put(Dst, 3821, batch*sizeof(TValue));
1714 }
1715 dasm_put(Dst, 3825, Dt2([ra+1]));
1716 if (num == 0) { /* Previous op was open. Restore L->top. */
1717 dasm_put(Dst, 1445, Dt2([J->pt->maxstacksize]), Dt1(->top));
1718 }
1719}
1720
1721/* ------------------------------------------------------------------------ */
1722
1723static void jit_op_arith(jit_State *J, int dest, int rkb, int rkc, int ev)
1724{
1725 const TValue *kkb = ISK(rkb) ? &J->pt->k[INDEXK(rkb)] : NULL;
1726 const TValue *kkc = ISK(rkc) ? &J->pt->k[INDEXK(rkc)] : NULL;
1727 const Value *kval;
1728 int idx, rev;
1729 int target = (ev == TM_LT || ev == TM_LE) ? jit_jmp_target(J) : 0;
1730 int hastail = 0;
1731
1732 /* The bytecode compiler already folds constants except for: k/0, k%0, */
1733 /* NaN results, k1<k2, k1<=k2. No point in optimizing these cases. */
1734 if (ISK(rkb&rkc)) goto fallback;
1735
1736 /* Avoid optimization when non-numeric constants are present. */
1737 if (kkb ? !ttisnumber(kkb) : (kkc && !ttisnumber(kkc))) goto fallback;
1738
1739 /* The TYPE hint selects numeric inlining and/or fallback encoding. */
1740 switch (ttype(hint_get(J, TYPE))) {
1741 case LUA_TNIL: hastail = 1; break; /* No hint: numeric + fallback. */
1742 case LUA_TNUMBER: break; /* Numbers: numeric + deoptimization. */
1743 default: goto fallback; /* Mixed/other types: fallback only. */
1744 }
1745
1746 /* The checks above ensure: at most one of the operands is a constant. */
1747 /* Reverse operation and swap operands so the 2nd operand is a variable. */
1748 if (kkc) { kval = &kkc->value; idx = rkb; rev = 1; }
1749 else { kval = kkb ? &kkb->value : NULL; idx = rkc; rev = 0; }
1750
1751 /* Special handling for some operators. */
1752 switch (ev) {
1753 case TM_MOD:
1754 /* Check for modulo with positive numbers, so we can use fprem. */
1755 if (kval) {
1756 if (kval->na[1] < 0) { hastail = 0; goto fallback; } /* x%-k, -k%x */
1757 dasm_put(Dst, 3850, Dt2([idx].tt), Dt2([idx].value.na[1]));
1758 if (kkb) {
1759 dasm_put(Dst, 3868, Dt2([rkc].value), kval);
1760 } else {
1761 dasm_put(Dst, 3875, kval, Dt2([rkb].value));
1762 }
1763 } else {
1764 dasm_put(Dst, 3882, Dt2([rkb].tt), Dt2([rkc].tt), Dt2([rkb].value.na[1]), Dt2([rkc].value.na[1]), Dt2([rkc].value), Dt2([rkb].value));
1765 }
1766 dasm_put(Dst, 1387);
1767 goto fpstore;
1768 case TM_POW:
1769 if (hastail || !kval) break; /* Avoid this if not optimizing. */
1770 if (rev) { /* x^k for k > 0, k integer. */
1771 lua_Number n = kval->n;
1772 int k;
1773 lua_number2int(k, n);
1774 /* All positive integers would work. But need to limit code explosion. */
1775 if (k > 0 && k <= 65536 && (lua_Number)k == n) {
1776 dasm_put(Dst, 3916, Dt2([idx].tt), Dt2([idx]));
1777 for (; (k & 1) == 0; k >>= 1) { /* Handle leading zeroes (2^k). */
1778 dasm_put(Dst, 3928);
1779 }
1780 if ((k >>= 1) != 0) { /* Handle trailing bits. */
1781 dasm_put(Dst, 3931);
1782 for (; k != 1; k >>= 1) {
1783 if (k & 1) {
1784 dasm_put(Dst, 3936);
1785 }
1786 dasm_put(Dst, 3928);
1787 }
1788 dasm_put(Dst, 3939);
1789 }
1790 goto fpstore;
1791 }
1792 } else if (kval->n > (lua_Number)0) { /* k^x for k > 0. */
1793 int log2kval[3]; /* Enough storage for a tword (80 bits). */
1794 log2kval[2] = 0; /* Avoid leaking garbage. */
1795 /* Double precision log2(k) doesn't cut it (3^x != 3 for x = 1). */
1796 ((void (*)(int *, double))J->jsub[JSUB_LOG2_TWORD])(log2kval, kval->n);
1797 dasm_put(Dst, 3942, log2kval[0], log2kval[1], log2kval[2], Dt2([idx].tt), Dt2([idx].value));
1798
1799 goto fpstore;
1800 }
1801 break;
1802 }
1803
1804 /* Check number type and load 1st operand. */
1805 if (kval) {
1806 dasm_put(Dst, 4013, Dt2([idx].tt));
1807 if ((kval)->n == (lua_Number)0) {
1808 dasm_put(Dst, 2404);
1809 } else if ((kval)->n == (lua_Number)1) {
1810 dasm_put(Dst, 2408);
1811 } else {
1812 dasm_put(Dst, 2411, kval);
1813 }
1814 } else {
1815 if (rkb == rkc) {
1816 dasm_put(Dst, 4022, Dt2([rkb].tt));
1817 } else {
1818 dasm_put(Dst, 4027, Dt2([rkb].tt), Dt2([rkc].tt));
1819 }
1820 dasm_put(Dst, 3920, Dt2([rkb].value));
1821 }
1822
1823 /* Encode arithmetic operation with 2nd operand. */
1824 switch ((ev<<1)+rev) {
1825 case TM_ADD<<1: case (TM_ADD<<1)+1:
1826 if (rkb == rkc) {
1827 dasm_put(Dst, 4041);
1828 } else {
1829 dasm_put(Dst, 4044, Dt2([idx].value));
1830 }
1831 break;
1832 case TM_SUB<<1:
1833 dasm_put(Dst, 4048, Dt2([idx].value));
1834 break;
1835 case (TM_SUB<<1)+1:
1836 dasm_put(Dst, 4052, Dt2([idx].value));
1837 break;
1838 case TM_MUL<<1: case (TM_MUL<<1)+1:
1839 if (rkb == rkc) {
1840 dasm_put(Dst, 3928);
1841 } else {
1842 dasm_put(Dst, 4056, Dt2([idx].value));
1843 }
1844 break;
1845 case TM_DIV<<1:
1846 dasm_put(Dst, 4060, Dt2([idx].value));
1847 break;
1848 case (TM_DIV<<1)+1:
1849 dasm_put(Dst, 4064, Dt2([idx].value));
1850 break;
1851 case TM_POW<<1:
1852 dasm_put(Dst, 4068, Dt2([idx].value), (ptrdiff_t)(pow));
1853 break;
1854 case (TM_POW<<1)+1:
1855 dasm_put(Dst, 4088, Dt2([idx].value), (ptrdiff_t)(pow));
1856 break;
1857 case TM_UNM<<1: case (TM_UNM<<1)+1:
1858 dasm_put(Dst, 4108);
1859 break;
1860 default: /* TM_LT or TM_LE. */
1861 dasm_put(Dst, 1325, Dt2([idx].value));
1862 if (J->flags & JIT_F_CPU_CMOV) {
1863 dasm_put(Dst, 3293);
1864 } else {
1865 dasm_put(Dst, 3298);
1866 }
1867 dasm_put(Dst, 4111, dest?(J->nextpc+1):target);
1868 jit_assert(dest == 0 || dest == 1); /* Really cond. */
1869 switch (((rev^dest)<<1)+(dest^(ev == TM_LT))) {
1870 case 0:
1871 dasm_put(Dst, 4115, target);
1872 break;
1873 case 1:
1874 dasm_put(Dst, 4119, target);
1875 break;
1876 case 2:
1877 dasm_put(Dst, 4123, target);
1878 break;
1879 case 3:
1880 dasm_put(Dst, 4127, target);
1881 break;
1882 }
1883 goto skipstore;
1884 }
1885fpstore:
1886 /* Store result and set result type (if necessary). */
1887 dasm_put(Dst, 933, Dt2([dest].value));
1888 if (dest != rkb && dest != rkc) {
1889 dasm_put(Dst, 1309, Dt2([dest].tt));
1890 }
1891
1892skipstore:
1893 if (!hastail) {
1894 jit_deopt_target(J, 0);
1895 return;
1896 }
1897
1898 dasm_put(Dst, 1626);
1899 dasm_put(Dst, 1541);
1900
1901fallback:
1902 /* Generic fallback for arithmetic ops. */
1903 if (kkb) {
1904 dasm_put(Dst, 3342, (ptrdiff_t)(kkb));
1905 } else {
1906 dasm_put(Dst, 3204, Dt2([rkb]));
1907 }
1908 if (kkc) {
1909 dasm_put(Dst, 3184, (ptrdiff_t)(kkc));
1910 } else {
1911 dasm_put(Dst, 3345, Dt2([rkc]));
1912 }
1913 if (target) { /* TM_LT or TM_LE. */
1914 dasm_put(Dst, 4131, Dt1(->savedpc), (ptrdiff_t)((J->nextins+1)), (ptrdiff_t)(ev==TM_LT?luaV_lessthan:luaV_lessequal), Dt1(->base));
1915 if (dest) { /* cond */
1916 dasm_put(Dst, 1479, target);
1917 } else {
1918 dasm_put(Dst, 4154, target);
1919 }
1920 } else {
1921 if (dest) {
1922 dasm_put(Dst, 787, dest*sizeof(TValue));
1923 }
1924 dasm_put(Dst, 4158, Dt1(->savedpc), (ptrdiff_t)(J->nextins), ev, (ptrdiff_t)(luaV_arith), Dt1(->base));
1925 }
1926
1927 if (hastail) {
1928 dasm_put(Dst, 1644);
1929 }
1930}
1931
1932/* ------------------------------------------------------------------------ */
1933
1934static void jit_fallback_len(lua_State *L, StkId ra, const TValue *rb)
1935{
1936 switch (ttype(rb)) {
1937 case LUA_TTABLE:
1938 setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
1939 break;
1940 case LUA_TSTRING:
1941 setnvalue(ra, cast_num(tsvalue(rb)->len));
1942 break;
1943 default: {
1944 const TValue *tm = luaT_gettmbyobj(L, rb, TM_LEN);
1945 if (ttisfunction(tm)) {
1946 ptrdiff_t rasave = savestack(L, ra);
1947 setobj2s(L, L->top, tm);
1948 setobj2s(L, L->top+1, rb);
1949 luaD_checkstack(L, 2);
1950 L->top += 2;
1951 luaD_call(L, L->top - 2, 1);
1952 ra = restorestack(L, rasave);
1953 L->top--;
1954 setobjs2s(L, ra, L->top);
1955 } else {
1956 luaG_typeerror(L, rb, "get length of");
1957 }
1958 break;
1959 }
1960 }
1961}
1962
1963static void jit_op_len(jit_State *J, int dest, int rb)
1964{
1965 switch (ttype(hint_get(J, TYPE))) {
1966 case LUA_TTABLE:
1967 jit_deopt_target(J, 0);
1968 dasm_put(Dst, 4179, Dt2([rb].tt), Dt2([rb].value), (ptrdiff_t)(luaH_getn), Dt2([dest].value), Dt2([dest].tt));
1969 break;
1970 case LUA_TSTRING:
1971 jit_deopt_target(J, 0);
1972 dasm_put(Dst, 4212, Dt2([rb].tt), Dt2([rb].value), DtB(->tsv.len), Dt2([dest].value), Dt2([dest].tt));
1973 break;
1974 default:
1975 dasm_put(Dst, 3204, Dt2([rb]));
1976 if (dest) {
1977 dasm_put(Dst, 787, dest*sizeof(TValue));
1978 }
1979 dasm_put(Dst, 4237, Dt1(->savedpc), (ptrdiff_t)(J->nextins), (ptrdiff_t)(jit_fallback_len), Dt1(->base));
1980 break;
1981 }
1982}
1983
1984static void jit_op_not(jit_State *J, int dest, int rb)
1985{
1986 /* l_isfalse() without a branch -- truly devious. */
1987 /* ((value & tt) | (tt>>1)) is only zero for nil/false. */
1988 /* Assumes: LUA_TNIL == 0, LUA_TBOOLEAN == 1, bvalue() == 0/1 */
1989 dasm_put(Dst, 4258, Dt2([rb].tt), Dt2([rb].value), Dt2([dest].tt), Dt2([dest].value));
1990}
1991
1992/* ------------------------------------------------------------------------ */
1993
1994static void jit_op_concat(jit_State *J, int dest, int first, int last)
1995{
1996 int num = last-first+1;
1997 if (num == 2 && ttisstring(hint_get(J, TYPE))) { /* Optimize common case. */
1998 if (first) {
1999 dasm_put(Dst, 787, first*sizeof(TValue));
2000 }
2001 dasm_put(Dst, 4288, Dt2([dest].value), Dt2([dest].tt));
2002 } else { /* Generic fallback. */
2003 dasm_put(Dst, 4302, Dt1(->savedpc), (ptrdiff_t)(J->nextins), num, last, (ptrdiff_t)(luaV_concat), Dt1(->base));
2004 if (dest != first) {
2005 if (J->flags & JIT_F_CPU_SSE2) {
2006 dasm_put(Dst, 821, Dt2([first].tt), Dt2([first].value), Dt2([dest].tt), Dt2([dest].value));
2007 } else {
2008 dasm_put(Dst, 839, Dt2([first].value), Dt2([first].value.na[1]), Dt2([first].tt), Dt2([dest].value), Dt2([dest].value.na[1]), Dt2([dest].tt));
2009 }
2010 }
2011 }
2012 jit_checkGC(J); /* Always do this, even for the optimized variant. */
2013
2014}
2015
2016/* ------------------------------------------------------------------------ */
2017
2018static void jit_op_eq(jit_State *J, int cond, int rkb, int rkc)
2019{
2020 int target = jit_jmp_target(J);
2021 int condtarget = cond ? (J->nextpc+1) : target;
2022 jit_assert(cond == 0 || cond == 1);
2023
2024 /* Comparison of two constants. Evaluate at compile time. */
2025 if (ISK(rkb&rkc)) {
2026 if ((rkb == rkc) == cond) { /* Constants are already unique. */
2027 dasm_put(Dst, 665, target);
2028 }
2029 return;
2030 }
2031
2032 if (ISK(rkb|rkc)) { /* Compare a variable and a constant. */
2033 const TValue *kk;
2034 if (ISK(rkb)) { int t = rkc; rkc = rkb; rkb = t; } /* rkc holds const. */
2035 kk = &J->pt->k[INDEXK(rkc)];
2036 switch (ttype(kk)) {
2037 case LUA_TNIL:
2038 dasm_put(Dst, 4493, Dt2([rkb].tt));
2039 break;
2040 case LUA_TBOOLEAN:
2041 if (bvalue(kk)) {
2042 dasm_put(Dst, 4498, Dt2([rkb].tt), Dt2([rkb].value));
2043 } else {
2044 dasm_put(Dst, 4509, Dt2([rkb].tt), Dt2([rkb].value));
2045 }
2046 break;
2047 case LUA_TNUMBER:
2048 dasm_put(Dst, 4517, Dt2([rkb].tt), condtarget, Dt2([rkb].value), &kk->value);
2049 if (J->flags & JIT_F_CPU_CMOV) {
2050 dasm_put(Dst, 3293);
2051 } else {
2052 dasm_put(Dst, 3298);
2053 }
2054 dasm_put(Dst, 4111, condtarget);
2055 break;
2056 case LUA_TSTRING:
2057 dasm_put(Dst, 4531, Dt2([rkb].tt), condtarget, Dt2([rkb].value), (ptrdiff_t)(rawtsvalue(kk)));
2058 break;
2059 default: jit_assert(0); break;
2060 }
2061 } else { /* Compare two variables. */
2062 dasm_put(Dst, 4543, Dt2([rkb].tt), Dt2([rkc].tt), condtarget);
2063 switch (ttype(hint_get(J, TYPE))) {
2064 case LUA_TNUMBER:
2065 jit_deopt_target(J, 0);
2066 dasm_put(Dst, 4553, Dt2([rkb].value), Dt2([rkc].value));
2067 if (J->flags & JIT_F_CPU_CMOV) {
2068 dasm_put(Dst, 3293);
2069 } else {
2070 dasm_put(Dst, 3298);
2071 }
2072 dasm_put(Dst, 4111, condtarget);
2073 break;
2074 case LUA_TSTRING:
2075 jit_deopt_target(J, 0);
2076 dasm_put(Dst, 4568, Dt2([rkb].value), Dt2([rkc].value));
2077 break;
2078 default:
2079 dasm_put(Dst, 4583, Dt2([rkc]), Dt2([rkb]), Dt1(->savedpc), (ptrdiff_t)(J->nextins), (ptrdiff_t)(luaV_equalval), Dt1(->base));
2080 break;
2081 }
2082 }
2083 if (cond) {
2084 dasm_put(Dst, 4154, target);
2085 } else {
2086 dasm_put(Dst, 1479, target);
2087 }
2088}
2089
2090/* ------------------------------------------------------------------------ */
2091
2092static void jit_op_test(jit_State *J, int cond, int dest, int src)
2093{
2094 int target = jit_jmp_target(J);
2095
2096 /* l_isfalse() without a branch. But this time preserve tt/value. */
2097 /* (((value & tt) * 2 + tt) >> 1) is only zero for nil/false. */
2098 /* Assumes: 3*tt < 2^32, LUA_TNIL == 0, LUA_TBOOLEAN == 1, bvalue() == 0/1 */
2099 dasm_put(Dst, 4611, Dt2([src].tt), Dt2([src].value));
2100
2101 /* Check if we can omit the stack copy. */
2102 if (dest == src) { /* Yes, invert branch condition. */
2103 if (cond) {
2104 dasm_put(Dst, 1479, target);
2105 } else {
2106 dasm_put(Dst, 4154, target);
2107 }
2108 } else { /* No, jump around copy code. */
2109 if (cond) {
2110 dasm_put(Dst, 4627);
2111 } else {
2112 dasm_put(Dst, 4632);
2113 }
2114 dasm_put(Dst, 4637, Dt2([src].value.na[1]), Dt2([dest].tt), Dt2([dest].value), Dt2([dest].value.na[1]), target);
2115 }
2116}
2117
2118static void jit_op_jmp(jit_State *J, int target)
2119{
2120 dasm_put(Dst, 665, target);
2121}
2122
2123/* ------------------------------------------------------------------------ */
2124
2125enum { FOR_IDX, FOR_LIM, FOR_STP, FOR_EXT };
2126
2127static const char *const jit_for_coerce_error[] = {
2128 LUA_QL("for") " initial value must be a number",
2129 LUA_QL("for") " limit must be a number",
2130 LUA_QL("for") " step must be a number",
2131};
2132
2133/* Try to coerce for slots with strings to numbers in place or complain. */
2134static void jit_for_coerce(lua_State *L, TValue *o)
2135{
2136 int i;
2137 for (i = FOR_IDX; i <= FOR_STP; i++, o++) {
2138 lua_Number num;
2139 if (ttisnumber(o)) continue;
2140 if (ttisstring(o) && luaO_str2d(svalue(o), &num)) {
2141 setnvalue(o, num);
2142 } else {
2143 luaG_runerror(L, jit_for_coerce_error[i]);
2144 }
2145 }
2146}
2147
2148static void jit_op_forprep(jit_State *J, int ra, int target)
2149{
2150 const TValue *step = hint_get(J, FOR_STEP_K);
2151 if (ttisnumber(step)) {
2152 dasm_put(Dst, 4654, Dt2([ra+FOR_IDX].tt), Dt2([ra+FOR_LIM].tt), Dt2([ra+FOR_LIM].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_EXT].value));
2153 if (J->flags & JIT_F_CPU_CMOV) {
2154 dasm_put(Dst, 3293);
2155 } else {
2156 dasm_put(Dst, 3298);
2157 }
2158 dasm_put(Dst, 1309, Dt2([ra+FOR_EXT].tt));
2159 if (nvalue(step) < (lua_Number)0) {
2160 dasm_put(Dst, 4115, target+1);
2161 } else {
2162 dasm_put(Dst, 4123, target+1);
2163 }
2164 } else {
2165 dasm_put(Dst, 4683, Dt2([ra+FOR_IDX].tt), Dt2([ra+FOR_LIM].tt), Dt2([ra+FOR_STP].tt), Dt2([ra+FOR_STP].value.na[1]), Dt2([ra+FOR_LIM].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_EXT].value));
2166 if (J->flags & JIT_F_CPU_CMOV) {
2167 dasm_put(Dst, 3293);
2168 } else {
2169 dasm_put(Dst, 3298);
2170 }
2171 dasm_put(Dst, 4732, Dt2([ra+FOR_EXT].tt), target+1);
2172 }
2173 if (ttisnumber(hint_get(J, TYPE))) {
2174 jit_deopt_target(J, 0);
2175 } else {
2176 dasm_put(Dst, 679);
2177 dasm_put(Dst, 4743, Dt2([ra]), Dt1(->savedpc), (ptrdiff_t)(J->nextins), (ptrdiff_t)(jit_for_coerce));
2178 }
2179}
2180
2181static void jit_op_forloop(jit_State *J, int ra, int target)
2182{
2183 const TValue *step = hint_getpc(J, FOR_STEP_K, target-1);
2184 if (ttisnumber(step)) {
2185 dasm_put(Dst, 4766, Dt2([ra+FOR_LIM].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_STP].value), Dt2([ra+FOR_EXT].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_EXT].tt));
2186 if (J->flags & JIT_F_CPU_CMOV) {
2187 dasm_put(Dst, 3293);
2188 } else {
2189 dasm_put(Dst, 3298);
2190 }
2191 if (nvalue(step) < (lua_Number)0) {
2192 dasm_put(Dst, 4127, target);
2193 } else {
2194 dasm_put(Dst, 4119, target);
2195 }
2196 } else {
2197 dasm_put(Dst, 4789, Dt2([ra+FOR_STP].value.na[1]), Dt2([ra+FOR_LIM].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_STP].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_EXT].value), Dt2([ra+FOR_EXT].tt));
2198 if (J->flags & JIT_F_CPU_CMOV) {
2199 dasm_put(Dst, 3293);
2200 } else {
2201 dasm_put(Dst, 3298);
2202 }
2203 dasm_put(Dst, 4127, target);
2204 }
2205}
2206
2207/* ------------------------------------------------------------------------ */
2208
2209static void jit_op_tforloop(jit_State *J, int ra, int nresults)
2210{
2211 int target = jit_jmp_target(J);
2212 int i;
2213 if (jit_inline_tforloop(J, ra, nresults, target)) return; /* Inlined? */
2214 for (i = 2; i >= 0; i--) {
2215 if (J->flags & JIT_F_CPU_SSE2) {
2216 dasm_put(Dst, 821, Dt2([ra+i].tt), Dt2([ra+i].value), Dt2([ra+i+3].tt), Dt2([ra+i+3].value));
2217 } else {
2218 dasm_put(Dst, 839, Dt2([ra+i].value), Dt2([ra+i].value.na[1]), Dt2([ra+i].tt), Dt2([ra+i+3].value), Dt2([ra+i+3].value.na[1]), Dt2([ra+i+3].tt));
2219 }
2220 }
2221 jit_op_call(J, ra+3, 2, nresults);
2222 dasm_put(Dst, 4827, Dt2([ra+3].tt));
2223 if (J->flags & JIT_F_CPU_SSE2) {
2224 dasm_put(Dst, 821, Dt2([ra+3].tt), Dt2([ra+3].value), Dt2([ra+2].tt), Dt2([ra+2].value));
2225 } else {
2226 dasm_put(Dst, 839, Dt2([ra+3].value), Dt2([ra+3].value.na[1]), Dt2([ra+3].tt), Dt2([ra+2].value), Dt2([ra+2].value.na[1]), Dt2([ra+2].tt));
2227 }
2228 dasm_put(Dst, 4649, target);
2229}
2230
2231/* ------------------------------------------------------------------------ */
2232
2233static void jit_op_close(jit_State *J, int ra)
2234{
2235 if (ra) {
2236 dasm_put(Dst, 4836, Dt2([ra]));
2237 } else {
2238 dasm_put(Dst, 4844);
2239 }
2240 dasm_put(Dst, 1734, (ptrdiff_t)(luaF_close));
2241}
2242
2243static void jit_op_closure(jit_State *J, int dest, int ptidx)
2244{
2245 Proto *npt = J->pt->p[ptidx];
2246 int nup = npt->nups;
2247 if (!J->pt->is_vararg) {
2248 dasm_put(Dst, 4849, Dt2([-1].value));
2249 } else {
2250 dasm_put(Dst, 4853, Dt1(->ci), Dt4(->func), Dt3(->value));
2251 }
2252 dasm_put(Dst, 4863, Dt5(->env), nup, (ptrdiff_t)(luaF_newLclosure), Dt5(->p), (ptrdiff_t)(npt), Dt2([dest].value), Dt2([dest].tt));
2253 /* Process pseudo-instructions for upvalues. */
2254 if (nup > 0) {
2255 const Instruction *uvcode = J->nextins;
2256 int i, uvuv;
2257 /* Check which of the two types we need. */
2258 for (i = 0, uvuv = 0; i < nup; i++)
2259 if (GET_OPCODE(uvcode[i]) == OP_GETUPVAL) uvuv++;
2260 /* Copy upvalues from parent first. */
2261 if (uvuv) {
2262 /* LCL:eax->upvals (new closure) <-- LCL:edi->upvals (own closure). */
2263 for (i = 0; i < nup; i++)
2264 if (GET_OPCODE(uvcode[i]) == OP_GETUPVAL) {
2265 dasm_put(Dst, 4895, Dt5(->upvals[GETARG_B(uvcode[i])]), Dt5(->upvals[i]));
2266 }
2267 }
2268 /* Next find or create upvalues for our own stack slots. */
2269 if (nup > uvuv) {
2270 dasm_put(Dst, 909);
2271 /* LCL:edi->upvals (new closure) <-- upvalue for stack slot. */
2272 for (i = 0; i < nup; i++)
2273 if (GET_OPCODE(uvcode[i]) == OP_MOVE) {
2274 int rb = GETARG_B(uvcode[i]);
2275 if (rb) {
2276 dasm_put(Dst, 4836, Dt2([rb]));
2277 } else {
2278 dasm_put(Dst, 4844);
2279 }
2280 dasm_put(Dst, 4902, (ptrdiff_t)(luaF_findupval), Dt5(->upvals[i]));
2281 }
2282 }
2283 J->combine += nup; /* Skip pseudo-instructions. */
2284 }
2285 jit_checkGC(J);
2286}
2287
2288/* ------------------------------------------------------------------------ */
2289
2290static void jit_op_vararg(jit_State *J, int dest, int num)
2291{
2292 if (num < 0) { /* Copy all varargs. */
2293 dasm_put(Dst, 4911, Dt1(->ci), Dt4(->func), (1+J->pt->numparams)*sizeof(TValue), J->pt->maxstacksize*sizeof(TValue), Dt1(->stack_last), Dt2([dest]));
2294 dasm_put(Dst, 4967, Dt1(->top), (ptrdiff_t)(luaD_growstack), Dt1(->base));
2295 } else if (num > 0) { /* Copy limited number of varargs. */
2296 dasm_put(Dst, 4993, Dt1(->ci), Dt4(->func), (1+J->pt->numparams)*sizeof(TValue), Dt2([dest]), Dt2([dest+num]), Dt3([0].tt), sizeof(TValue));
2297 }
2298}
2299
2300/* ------------------------------------------------------------------------ */
2301
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_x86_inline.dash b/libraries/LuaJIT-1.1.7/src/ljit_x86_inline.dash
new file mode 100644
index 0000000..203642f
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_x86_inline.dash
@@ -0,0 +1,625 @@
1/*
2** Function inlining support for x86 CPUs.
3** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
4*/
5
6/* ------------------------------------------------------------------------ */
7
8/* Private structure holding function inlining info. */
9typedef struct jit_InlineInfo {
10 int func; /* Function slot. 1st arg slot = func+1. */
11 int res; /* 1st result slot. Overlaps func/ci->func. */
12 int nargs; /* Number of args. */
13 int nresults; /* Number of results. */
14 int xnargs; /* Expected number of args. */
15 int xnresults; /* Returned number of results. */
16 int hidx; /* Library/function index numbers. */
17} jit_InlineInfo;
18
19/* ------------------------------------------------------------------------ */
20
21enum { TFOR_FUNC, TFOR_TAB, TFOR_CTL, TFOR_KEY, TFOR_VAL };
22
23static void jit_inline_base(jit_State *J, jit_InlineInfo *ii)
24{
25 int func = ii->func;
26 switch (JIT_IH_IDX(ii->hidx)) {
27 case JIT_IH_BASE_PAIRS:
28 case JIT_IH_BASE_IPAIRS:
29 |// Easy for regular calls: res == func. Not inlined for tailcalls.
30 |// Guaranteed to be inlined only if used in conjunction with TFORLOOP.
31 |// So we omit setting the iterator function and fake the control var.
32 | istable func+TFOR_TAB; jne L_DEOPTIMIZE // Caveat: deopt TFORLOOP, too!
33 | xor eax, eax // Assumes: LUA_TNIL == 0.
34 | mov BASE[func+TFOR_CTL].tt, eax // Fake nil type.
35 | mov BASE[func+TFOR_CTL].value, eax // Hidden control var = 0.
36 |// mov BASE[func+TFOR_FUNC].tt, eax // Kill function (not needed).
37 |.mfmap
38 | .word JIT_MFM_DEOPT_PAIRS, J->nextpc-1 // Deoptimize TFORLOOP, too.
39 |.code
40 break;
41 default:
42 jit_assert(0);
43 break;
44 }
45}
46
47/* ------------------------------------------------------------------------ */
48
49#ifndef COCO_DISABLE
50
51/* Helper function for inlined coroutine.resume(). */
52static StkId jit_coroutine_resume(lua_State *L, StkId base, int nresults)
53{
54 lua_State *co = thvalue(base-1);
55 /* Check for proper usage. Merge of lua_resume() and auxresume() checks. */
56 if (co->status != LUA_YIELD) {
57 if (co->status > LUA_YIELD) {
58errdead:
59 setsvalue(L, base-1, luaS_newliteral(L, "cannot resume dead coroutine"));
60 goto err;
61 } else if (co->ci != co->base_ci) {
62 setsvalue(L, base-1,
63 luaS_newliteral(L, "cannot resume non-suspended coroutine"));
64 goto err;
65 } else if (co->base == co->top) {
66 goto errdead;
67 }
68 }
69 {
70 ptrdiff_t ndelta = (char *)L->top - (char *)base;
71 int nargs = ndelta/sizeof(TValue); /* Compute nargs. */
72 int status;
73 if ((char *)co->stack_last-(char *)co->top <= ndelta) {
74 co->ci->top = (StkId)(((char *)co->top) + ndelta); /* Ok before grow. */
75 luaD_growstack(co, nargs); /* Grow thread stack. */
76 }
77 /* Copy args. */
78 co->top = (StkId)(((char *)co->top) + ndelta);
79 { StkId t = co->top, f = L->top; while (f > base) setobj2s(co, --t, --f); }
80 L->top = base;
81 status = luaCOCO_resume(co, nargs); /* Resume Coco thread. */
82 if (status == 0 || status == LUA_YIELD) { /* Ok. */
83 StkId f;
84 if (nresults == 0) return NULL;
85 if (nresults == -1) {
86 luaD_checkstack(L, co->top - co->base); /* Grow own stack. */
87 }
88 base = L->top - 2;
89 setbvalue(base++, 1); /* true */
90 /* Copy results. Fill unused result slots with nil. */
91 f = co->base;
92 while (--nresults != 0 && f < co->top) setobj2s(L, base++, f++);
93 while (nresults-- > 0) setnilvalue(base++);
94 co->top = co->base;
95 return base;
96 } else { /* Error. */
97 base = L->top;
98 setobj2s(L, base-1, co->top-1); /* Copy error object. */
99err:
100 setbvalue(base-2, 0); /* false */
101 nresults -= 2;
102 while (--nresults >= 0) setnilvalue(base+nresults); /* Fill results. */
103 return base;
104 }
105 }
106}
107
108static void jit_inline_coroutine(jit_State *J, jit_InlineInfo *ii)
109{
110 int arg = ii->func+1;
111 int res = ii->res;
112 int i;
113 switch (JIT_IH_IDX(ii->hidx)) {
114 case JIT_IH_COROUTINE_YIELD:
115 | cmp aword [L+((int)&LHASCOCO((lua_State *)0))], 0 // Got a C stack?
116 | je L_DEOPTIMIZE
117 | mov L->savedpc, &J->nextins // Debugger-friendly.
118 | add BASE, arg*#TVALUE
119 if (ii->nargs >= 0) { /* Previous op was not open and did not set TOP. */
120 | lea TOP, BASE[ii->nargs]
121 }
122 | mov L->base, BASE
123 | mov L->top, TOP
124 | call &luaCOCO_yield, L
125 | mov BASE, L->base
126 | mov TOP, L->top
127 jit_assert(ii->nresults >= 0 && ii->nresults <= EXTRA_STACK);
128 for (i = 0; i < ii->nresults; i++) {
129 | setnilvalue TOP[i] // Clear undefined result.
130 | copyslot BASE[res+i], BASE[arg+i] // Move result down.
131 }
132 ii->nargs = -1; /* Force restore of L->top. */
133 break;
134 case JIT_IH_COROUTINE_RESUME:
135 jit_assert(ii->nargs != 0 && ii->res == ii->func);
136 | add BASE, (arg+1)*#TVALUE
137 if (ii->nargs >= 0) { /* Previous op was not open and did not set TOP. */
138 | lea TOP, BASE[ii->nargs-1]
139 } else {
140 | cmp TOP, BASE; jb L_DEOPTIMIZE // No thread arg? Deoptimize.
141 }
142 | istt -1, LUA_TTHREAD; jne L_DEOPTIMIZE // Wrong type? Deoptimize.
143 | mov L:eax, BASE[-1].value
144 | cmp aword [L:eax+((int)&LHASCOCO((lua_State *)0))], 0
145 | je L_DEOPTIMIZE // No C stack? Deoptimize.
146 | mov L->savedpc, &J->nextins // Debugger-friendly.
147 | mov L->top, TOP
148 | call &jit_coroutine_resume, L, BASE, ii->nresults
149 | mov BASE, L->base
150 if (ii->nresults == -1) {
151 | mov TOP, eax
152 }
153 ii->nargs = -1; /* Force restore of L->top. */
154 break;
155 default:
156 jit_assert(0);
157 break;
158 }
159}
160
161#endif /* COCO_DISABLE */
162
163/* ------------------------------------------------------------------------ */
164
165static void jit_inline_string(jit_State *J, jit_InlineInfo *ii)
166{
167 int arg = ii->func+1;
168 int res = ii->res;
169 switch (JIT_IH_IDX(ii->hidx)) {
170 case JIT_IH_STRING_LEN:
171 | isstring arg; jne L_DEOPTIMIZE
172 | mov TSTRING:ecx, BASE[arg].value
173 | fild aword TSTRING:ecx->tsv.len // size_t
174 | settt BASE[res], LUA_TNUMBER
175 | fstp qword BASE[res].value
176 break;
177 case JIT_IH_STRING_SUB:
178 /* TODO: inline numeric constants with help from the optimizer. */
179 /* But this would save only another 15-20% in a trivial loop. */
180 jit_assert(ii->nargs >= 2); /* Open op caveat is ok, too. */
181 if (ii->nargs > 2) {
182 | lea TOP, BASE[arg]
183 | call ->STRING_SUB3
184 | setsvalue BASE[res], eax
185 } else {
186 | lea TOP, BASE[arg]
187 | call ->STRING_SUB2
188 | setsvalue BASE[res], eax
189 }
190 break;
191 case JIT_IH_STRING_CHAR:
192 | isnumber arg; jne L_DEOPTIMIZE
193 | lea eax, L->env // Abuse L->env to hold temp string.
194 | fld qword BASE[arg].value
195 | fistp dword [eax] // LSB is at start (little-endian).
196 | cmp dword [eax], 255; ja L_DEOPTIMIZE
197 | call &luaS_newlstr, L, eax, 1
198 | setsvalue BASE[res], eax
199 break;
200 default:
201 jit_assert(0);
202 break;
203 }
204
205 |//-----------------------------------------------------------------------
206 |.jsub STRING_SUB3 // string.sub(str, start, end)
207 | mov eax, TOP[0].tt; shl eax, 4; or eax, TOP[1].tt; shl eax, 4
208 | or eax, TOP[2].tt; sub eax, LUA_TSTR_NUM_NUM
209 | jne ->DEOPTIMIZE_CALLER // Wrong types? Deoptimize.
210 | // eax must be zero here!
211 | fld qword TOP[1].value
212 | fld qword TOP[2].value
213 | fistp aword TMP3 // size_t
214 | fistp aword TMP2 // size_t
215 | mov TSTRING:ecx, TOP[0].value
216 | mov TOP, aword TSTRING:ecx->tsv.len // size_t
217 | mov edx, TMP3
218 | cmp TOP, edx
219 | jb >4
220 |1:
221 | or eax, TMP2 // eax is known to be zero.
222 | jle >6 // start <= 0?
223 |2:
224 | sub edx, eax // newlen = end-start
225 | jl >7 // start > end?
226 | lea ecx, [TSTRING:ecx+eax+#TSTRING-1] // svalue()-1+start
227 | inc edx
228 |3:
229 | mov ARG2, L // First arg for tailcall is ARG2.
230 | mov ARG3, ecx // Pointer to start.
231 | mov ARG4, edx // Length.
232 | mov GL:edi, L->l_G
233 | mov eax, GL:edi->totalbytes // size_t
234 | cmp eax, GL:edi->GCthreshold // size_t
235 | jae >8 // G->totalbytes >= G->GCthreshold?
236 | jmp &luaS_newlstr // Tailcall to C function.
237 |
238 |4: // Negative end or overflow.
239 | jl >5
240 | lea edx, [edx+TOP+1] // end = end+(len+1)
241 | jmp <1
242 |5: // Overflow
243 | mov edx, TOP // end = len
244 | jmp <1
245 |
246 |6: // Negative start or underflow.
247 | je >5
248 | add eax, TOP // start = start+(len+1)
249 | inc eax
250 | jg <2 // start > 0?
251 |5: // Underflow.
252 | mov eax, 1 // start = 1
253 | jmp <2
254 |
255 |7: // Range underflow.
256 | xor edx, edx // Zero length.
257 | jmp <3 // Any pointer in ecx is ok.
258 |.endjsub
259 |
260 |//-----------------------------------------------------------------------
261 |.jsub STRING_SUB2 // string.sub(str, start)
262 | mov eax, TOP[0].tt; shl eax, 4; or eax, TOP[1].tt; sub eax, LUA_TSTR_NUM
263 | jne ->DEOPTIMIZE_CALLER // Wrong types? Deoptimize.
264 | // eax must be zero here!
265 | fld qword TOP[1].value
266 | fistp aword TMP2 // size_t
267 | mov TSTRING:ecx, TOP[0].value
268 | mov TOP, aword TSTRING:ecx->tsv.len // size_t
269 | mov edx, TOP
270 | jmp <1 // See STRING_SUB3.
271 |
272 |8: // GC threshold reached.
273 | sub esp, FRAME_OFFSET
274 | call &luaC_step, L
275 | add esp, FRAME_OFFSET
276 | mov BASE, L->base
277 | jmp &luaS_newlstr // Tailcall to C function.
278 |.endjsub
279}
280
281/* ------------------------------------------------------------------------ */
282
283/* Helper functions for inlined calls to table.*. */
284static void jit_table_insert(lua_State *L, TValue *arg)
285{
286 setobj2t(L, luaH_setnum(L, hvalue(arg), luaH_getn(hvalue(arg))+1), arg+1);
287 luaC_barriert(L, hvalue(arg), arg+1);
288}
289
290static TValue *jit_table_remove(lua_State *L, TValue *arg, TValue *res)
291{
292 int n = luaH_getn(hvalue(arg));
293 if (n == 0) {
294 setnilvalue(res); /* For the nresults == 1 case. Harmless otherwise. */
295 return res; /* For the nresults == -1 case. */
296 } else {
297 TValue *val = luaH_setnum(L, hvalue(arg), n);
298 setobj2s(L, res, val);
299 setnilvalue(val);
300 return res+1; /* For the nresults == -1 case. */
301 }
302}
303
304static void jit_inline_table(jit_State *J, jit_InlineInfo *ii)
305{
306 int arg = ii->func+1;
307 int res = ii->res;
308 | istable arg; jne L_DEOPTIMIZE
309 switch (JIT_IH_IDX(ii->hidx)) {
310 case JIT_IH_TABLE_INSERT:
311 | lea TVALUE:eax, BASE[arg]
312 | call &jit_table_insert, L, TVALUE:eax
313 break;
314 case JIT_IH_TABLE_REMOVE:
315 | lea TVALUE:eax, BASE[arg]
316 | lea TVALUE:ecx, BASE[res]
317 | call &jit_table_remove, L, TVALUE:eax, TVALUE:ecx
318 if (ii->nresults == -1) {
319 ii->xnresults = -1;
320 | mov TOP, TVALUE:eax
321 }
322 break;
323 case JIT_IH_TABLE_GETN:
324 | mov TABLE:eax, BASE[arg].value
325 | call &luaH_getn, TABLE:eax
326 | mov TMP1, eax
327 | fild dword TMP1
328 | fstp qword BASE[res].value
329 | settt BASE[res], LUA_TNUMBER
330 break;
331 default:
332 jit_assert(0);
333 break;
334 }
335}
336
337/* ------------------------------------------------------------------------ */
338
339/* This typedef must match the libm function signature. */
340/* Serves as a check against wrong lua_Number or wrong calling conventions. */
341typedef lua_Number (*mathfunc_11)(lua_Number);
342
343/* Partially inlined math functions. */
344/* CHECK: must match with jit_hints.h and jit.opt_lib. */
345static const mathfunc_11 jit_mathfuncs_11[JIT_IH_MATH_SIN] = {
346 log, log10, exp, sinh, cosh, tanh, asin, acos, atan
347};
348
349/* FPU control words for ceil and floor (exceptions masked, full precision). */
350static const unsigned short jit_fpucw[2] = { 0x0b7f, 0x077f };
351
352static void jit_inline_math(jit_State *J, jit_InlineInfo *ii)
353{
354 int arg = ii->func+1;
355 int res = ii->res;
356 int idx = JIT_IH_IDX(ii->hidx);
357
358 if (idx < JIT_IH_MATH__21) {
359 | isnumber arg; jne L_DEOPTIMIZE
360 | fld qword BASE[arg].value
361 } else {
362 jit_assert(idx < JIT_IH_MATH__LAST);
363 | isnumber2 arg, arg+1; jne L_DEOPTIMIZE
364 }
365 switch (idx) {
366 /* We ignore sin/cos/tan range overflows (2^63 rad) just like -ffast-math. */
367 case JIT_IH_MATH_SIN:
368 | fsin
369 break;
370 case JIT_IH_MATH_COS:
371 | fcos
372 break;
373 case JIT_IH_MATH_TAN:
374 | fptan; fpop
375 break;
376 case JIT_IH_MATH_CEIL:
377 case JIT_IH_MATH_FLOOR:
378 | fnstcw word TMP1
379 | fldcw word [(ptrdiff_t)&jit_fpucw[idx-JIT_IH_MATH_CEIL]]
380 | frndint
381 | fldcw word TMP1
382 break;
383 case JIT_IH_MATH_ABS:
384 | fabs
385 break;
386 case JIT_IH_MATH_SQRT:
387 | fsqrt
388 break;
389 case JIT_IH_MATH_FMOD:
390 | fld qword BASE[arg+1].value
391 | fld qword BASE[arg].value
392 |1: ; fprem; fnstsw ax; sahf; jp <1
393 | fstp st1
394 break;
395 case JIT_IH_MATH_ATAN2:
396 |// Inlining is easier than calling atan2().
397 | fld qword BASE[arg].value
398 | fld qword BASE[arg+1].value
399 | fpatan
400 break;
401 default:
402 |// Partially inlined. Just call the libm function (__cdecl!).
403 | fstp FPARG1
404 | call &jit_mathfuncs_11[idx]
405 break;
406 }
407 | settt BASE[res], LUA_TNUMBER
408 | fstp qword BASE[res].value
409}
410
411/* ------------------------------------------------------------------------ */
412
413/* Try to inline a CALL or TAILCALL instruction. */
414static int jit_inline_call(jit_State *J, int func, int nargs, int nresults)
415{
416 const TValue *callable = hint_get(J, TYPE); /* TYPE hint = callable. */
417 int cltype = ttype(callable);
418 const TValue *oidx;
419 jit_InlineInfo ii;
420 int idx;
421
422 if (cltype != LUA_TFUNCTION) goto fail;
423 if (J->flags & JIT_F_DEBUG) goto fail; /* DWIM. */
424
425 oidx = hint_get(J, INLINE); /* INLINE hint = library/function index. */
426 if (!ttisnumber(oidx)) goto fail;
427
428 ii.hidx = (int)nvalue(oidx);
429 idx = JIT_IH_IDX(ii.hidx);
430
431 if (nresults == -2) { /* Tailcall. */
432 /* Tailcalls from vararg functions don't work with BASE[-1]. */
433 if (J->pt->is_vararg) goto fail; /* So forget about this rare case. */
434 ii.res = -1; /* Careful: 2nd result overlaps 1st stack slot. */
435 ii.nresults = -1;
436 } else {
437 ii.res = func;
438 ii.nresults = nresults;
439 }
440 ii.func = func;
441 ii.nargs = nargs;
442 ii.xnargs = ii.xnresults = 1; /* Default: 1 arg, 1 result. */
443
444 /* Check for the currently supported cases. */
445 switch (JIT_IH_LIB(ii.hidx)) {
446 case JIT_IHLIB_BASE:
447 switch (idx) {
448 case JIT_IH_BASE_PAIRS:
449 case JIT_IH_BASE_IPAIRS:
450 if (nresults == -2) goto fail; /* Not useful for tailcalls. */
451 ii.xnresults = 3;
452 goto check;
453 }
454 break;
455#ifndef COCO_DISABLE
456 case JIT_IHLIB_COROUTINE:
457 switch (idx) {
458 case JIT_IH_COROUTINE_YIELD:
459 /* Only support common cases: no tailcalls, low number of results. */
460 if (nresults < 0 || nresults > EXTRA_STACK) goto fail;
461 ii.xnargs = ii.xnresults = -1;
462 goto ok; /* Anything else is ok. */
463 case JIT_IH_COROUTINE_RESUME:
464 /* Only support common cases: no tailcalls, not with 0 args (error). */
465 if (nresults == -2 || nargs == 0) goto fail;
466 ii.xnargs = ii.xnresults = -1;
467 goto ok; /* Anything else is ok. */
468 }
469 break;
470#endif
471 case JIT_IHLIB_STRING:
472 switch (idx) {
473 case JIT_IH_STRING_LEN:
474 goto check;
475 case JIT_IH_STRING_SUB:
476 if (nargs < 2) goto fail; /* No support for open calls, too. */
477 goto ok; /* 2 or more args are ok. */
478 case JIT_IH_STRING_CHAR:
479 goto check; /* Only single arg supported. */
480 }
481 break;
482 case JIT_IHLIB_TABLE:
483 switch (idx) {
484 case JIT_IH_TABLE_INSERT:
485 ii.xnargs = 2;
486 goto check; /* Only push (append) supported. */
487 case JIT_IH_TABLE_REMOVE:
488 goto check; /* Only pop supported. */
489 case JIT_IH_TABLE_GETN:
490 goto check;
491 }
492 break;
493 case JIT_IHLIB_MATH:
494 if (idx >= JIT_IH_MATH__LAST) goto fail;
495 if (idx >= JIT_IH_MATH__21) ii.xnargs = 2;
496 goto check;
497 }
498fail:
499 return cltype; /* Call could not be inlined. Return type of callable. */
500
501check:
502 if (nargs != ii.xnargs && nargs != -1) goto fail;
503 /* The optimizer already checks the number of results (avoid setnil). */
504
505ok: /* Whew, all checks done. Go for it! */
506
507 /* Start with the common leadin for inlined calls. */
508 jit_deopt_target(J, nargs);
509 |// Caveat: Must save TOP for open ops if jsub uses DEOPTIMIZE_CALLER.
510 | isfunction func
511 | jne L_DEOPTIMIZE // Not a function? Deoptimize.
512 | cmp aword BASE[func].value, &clvalue(callable)
513 | jne L_DEOPTIMIZE // Wrong closure? Deoptimize.
514 if (nargs == -1 && ii.xnargs >= 0) {
515 | lea eax, BASE[func+1+ii.xnargs]
516 | cmp TOP, eax
517 | jne L_DEOPTIMIZE // Wrong #args? Deoptimize.
518 }
519
520 /* Now inline the function itself. */
521 switch (JIT_IH_LIB(ii.hidx)) {
522 case JIT_IHLIB_BASE: jit_inline_base(J, &ii); break;
523#ifndef COCO_DISABLE
524 case JIT_IHLIB_COROUTINE: jit_inline_coroutine(J, &ii); break;
525#endif
526 case JIT_IHLIB_STRING: jit_inline_string(J, &ii); break;
527 case JIT_IHLIB_TABLE: jit_inline_table(J, &ii); break;
528 case JIT_IHLIB_MATH: jit_inline_math(J, &ii); break;
529 default: jit_assert(0); break;
530 }
531
532 /* And add the common leadout for inlined calls. */
533 if (ii.nresults == -1) {
534 if (ii.xnresults >= 0) {
535 | lea TOP, BASE[ii.res+ii.xnresults]
536 }
537 } else if (ii.nargs == -1) { /* Restore L->top only if needed. */
538 | lea TOP, BASE[J->pt->maxstacksize]
539 | mov L->top, TOP
540 }
541
542 if (nresults == -2) { /* Results are in place. Add return for tailcalls. */
543 | add esp, FRAME_OFFSET
544 | sub BASE, #BASE
545 | sub aword L->ci, #CI
546 | ret
547 }
548
549 return -1; /* Success, call has been inlined. */
550}
551
552/* ------------------------------------------------------------------------ */
553
554/* Helper function for inlined iterator code. Paraphrased from luaH_next. */
555/* TODO: GCC has trouble optimizing this. */
556static int jit_table_next(lua_State *L, TValue *ra)
557{
558 Table *t = hvalue(&ra[TFOR_TAB]);
559 int i = ra[TFOR_CTL].value.b; /* Hidden control variable. */
560 for (; i < t->sizearray; i++) { /* First the array part. */
561 if (!ttisnil(&t->array[i])) {
562 setnvalue(&ra[TFOR_KEY], cast_num(i+1));
563 setobj2s(L, &ra[TFOR_VAL], &t->array[i]);
564 ra[TFOR_CTL].value.b = i+1;
565 return 1;
566 }
567 }
568 for (i -= t->sizearray; i < sizenode(t); i++) { /* Then the hash part. */
569 if (!ttisnil(gval(gnode(t, i)))) {
570 setobj2s(L, &ra[TFOR_KEY], key2tval(gnode(t, i)));
571 setobj2s(L, &ra[TFOR_VAL], gval(gnode(t, i)));
572 ra[TFOR_CTL].value.b = i+1+t->sizearray;
573 return 1;
574 }
575 }
576 return 0; /* End of iteration. */
577}
578
579/* Try to inline a TFORLOOP instruction. */
580static int jit_inline_tforloop(jit_State *J, int ra, int nresults, int target)
581{
582 const TValue *oidx = hint_get(J, INLINE); /* INLINE hint = lib/func idx. */
583 int idx;
584
585 if (!ttisnumber(oidx)) return 0; /* No hint: don't inline anything. */
586 idx = (int)nvalue(oidx);
587 if (J->flags & JIT_F_DEBUG) return 0; /* DWIM. */
588
589 switch (idx) {
590 case JIT_IH_MKIDX(JIT_IHLIB_BASE, JIT_IH_BASE_PAIRS):
591 |// The type checks can be omitted -- see the iterator constructor.
592 | lea TOP, BASE[ra]
593 | call &jit_table_next, L, TOP
594 | test eax, eax
595 | jnz =>target
596 return 1; /* Success, iterator has been inlined. */
597 case JIT_IH_MKIDX(JIT_IHLIB_BASE, JIT_IH_BASE_IPAIRS):
598 |// The type checks can be omitted -- see the iterator constructor.
599 | mov eax, BASE[ra+TFOR_CTL].value // Hidden control variable.
600 | inc eax
601 | mov TABLE:edx, BASE[ra+TFOR_TAB].value // Table object.
602 | mov BASE[ra+TFOR_CTL].value, eax
603 | call &luaH_getnum, TABLE:edx, eax
604 | // This is really copyslot BASE[ra+TFOR_VAL], TVALUE:eax[0] plus compare.
605 | mov ecx, TVALUE:eax->tt
606 | test ecx, ecx // Assumes: LUA_TNIL == 0.
607 | jz >9 // nil value stops iteration.
608 | fild dword BASE[ra+TFOR_CTL].value // Set numeric key.
609 | settt BASE[ra+TFOR_KEY], LUA_TNUMBER
610 | fstp qword BASE[ra+TFOR_KEY].value
611 | mov edx, TVALUE:eax->value
612 | mov eax, TVALUE:eax->value.na[1] // Overwrites eax.
613 | mov BASE[ra+TFOR_VAL].tt, ecx // Copy value from table slot.
614 | mov BASE[ra+TFOR_VAL].value, edx
615 | mov BASE[ra+TFOR_VAL].value.na[1], eax
616 | jmp =>target
617 |9:
618 return 1; /* Success, iterator has been inlined. */
619 }
620
621 return 0; /* No support for inlining any other iterators. */
622}
623
624/* ------------------------------------------------------------------------ */
625
diff --git a/libraries/LuaJIT-1.1.7/src/ljitlib.c b/libraries/LuaJIT-1.1.7/src/ljitlib.c
new file mode 100644
index 0000000..4efc04d
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljitlib.c
@@ -0,0 +1,637 @@
1/*
2** Lua library for the JIT engine.
3** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
4*/
5
6#include <stdio.h>
7#include <string.h>
8
9#define ljitlib_c
10#define LUA_LIB
11
12#include "lua.h"
13#include "lauxlib.h"
14#include "luajit.h"
15#include "lualib.h"
16
17/* This file is not a pure C API user. Some internals are required. */
18#include "lobject.h"
19#include "lstate.h"
20#include "lstring.h"
21#include "ltable.h"
22#include "lfunc.h"
23#include "lgc.h"
24#include "lopcodes.h"
25
26#include "ljit.h"
27#include "ljit_hints.h"
28
29#define STRING_HINTS
30#include "ljit_hints.h"
31
32/* ------------------------------------------------------------------------ */
33
34/* Static pointer addresses used as registry keys. */
35/* The values do not matter, but must be different to prevent joining. */
36static const int regkey_frontend = 0x6c6a6c01;
37static const int regkey_comthread = 0x6c6a6c02;
38
39/* Check that the first argument is a Lua function and return its closure. */
40static Closure *check_LCL(lua_State *L)
41{
42 StkId o = L->base;
43 switch (lua_type(L, 1)) {
44 case LUA_TBOOLEAN:
45 o = (L->ci-1)->func;
46 case LUA_TFUNCTION:
47 if (isLfunction(o))
48 return clvalue(o);
49 break;
50 }
51 luaL_argerror(L, 1, "Lua function expected");
52 return NULL;
53}
54
55/* Create a new closure from a prototype. */
56/* Note: upvalues are assumed to be after first two slots. */
57static void push_LCL(lua_State *L, Proto *pt, Table *env)
58{
59 Closure *cl;
60 int i, nup = pt->nups;
61 /* Adjust the number of stack slots to the number of upvalues. */
62 luaL_checkstack(L, nup, "too many upvalues");
63 lua_settop(L, 2+nup);
64 /* Create a closure from the subroutine prototype. */
65 cl = luaF_newLclosure(L, nup, env);
66 cl->l.p = pt;
67 /* Allocate new upvalues and close them. */
68 for (i = 0; i < nup; i++)
69 cl->l.upvals[i] = luaF_findupval(L, L->base + (2+i));
70 luaF_close(L, L->base + 2);
71 lua_settop(L, 2); /* Remove upvalues. */
72 setclvalue(L, L->top++, cl); /* Return closure on top of stack. */
73 luaC_checkGC(L);
74}
75
76/* ------------------------------------------------------------------------ */
77
78/* Set JIT mode for the engine or a closure and/or its subroutines. */
79static int setmode(lua_State *L, int mode)
80{
81 int idx = 0;
82 switch (lua_type(L, 1)) {
83 case LUA_TNONE: /* jit.on/off() */
84 case LUA_TNIL: /* jit.on/off(nil) */
85 luaJIT_setmode(L, 0, mode | LUAJIT_MODE_ENGINE);
86 break;
87 case LUA_TFUNCTION: /* jit.on/off(func, nil|true|false) */
88 idx = 1;
89 case LUA_TBOOLEAN: /* jit.on/off(true, nil|true|false) (parent frame) */
90 if (lua_isboolean(L, 2))
91 mode |= lua_toboolean(L, 2)?LUAJIT_MODE_ALLFUNC:LUAJIT_MODE_ALLSUBFUNC;
92 else
93 mode |= LUAJIT_MODE_FUNC;
94 if (luaJIT_setmode(L, idx, mode) == 1) /* Ok? */
95 break;
96 default:
97 luaL_argerror(L, 1, "Lua function expected");
98 break;
99 }
100 return 0;
101}
102
103/* Set JIT mode to on: (re-)enable compilation. */
104static int j_on(lua_State *L)
105{
106 return setmode(L, LUAJIT_MODE_ON);
107}
108
109/* Set JIT mode to off: disable compilation. */
110static int j_off(lua_State *L)
111{
112 return setmode(L, LUAJIT_MODE_OFF);
113}
114
115/* Set JIT debug level. Defaults to maximum level for use with -j. */
116static int j_debug(lua_State *L)
117{
118 luaJIT_setmode(L, luaL_optinteger(L, 1, 100), LUAJIT_MODE_DEBUG);
119 return 0;
120}
121
122/* ------------------------------------------------------------------------ */
123
124/* Report the compilation status. */
125static int compstatus(lua_State *L, int status)
126{
127 if (status == -1)
128 return luaL_argerror(L, 1, "Lua function expected");
129 else if (status == JIT_S_OK)
130 return 0;
131 else {
132 lua_pushinteger(L, status);
133 return 1;
134 }
135}
136
137/* Compile a function. Pass typical args to help the optimizer. */
138static int j_compile(lua_State *L)
139{
140 int nargs = lua_gettop(L) - 1;
141 return compstatus(L, nargs >= 0 ? luaJIT_compile(L, nargs) : -1);
142}
143
144/* Recursively compile all subroutine prototypes. */
145static int rec_compile(lua_State *L, Proto *pt, Table *env, int stoponerror)
146{
147 int rstatus = JIT_S_OK;
148 int i;
149 for (i = 0; i < pt->sizep; i++) {
150 Proto *pti = pt->p[i];
151 int status;
152 push_LCL(L, pti, env); /* Assumes stack is at 2 (no upvalues). */
153 status = luaJIT_compile(L, 0);
154 lua_settop(L, 2); /* Clear stack */
155 if (status != JIT_S_OK) {
156 rstatus = status;
157 if (stoponerror) break;
158 }
159 status = rec_compile(L, pti, env, stoponerror);
160 if (status != JIT_S_OK) {
161 rstatus = status;
162 if (stoponerror) break;
163 }
164 }
165 return rstatus;
166}
167
168/* Compile all subroutines of a function. */
169/* Note: the function itself is _not_ compiled (use jit.compile()). */
170static int j_compilesub(lua_State *L)
171{
172 Closure *cl = check_LCL(L);
173 int stoponerror = lua_toboolean(L, 2); /* Stop on first error? */
174 lua_settop(L, 2);
175 return compstatus(L, rec_compile(L, cl->l.p, cl->l.env, stoponerror));
176}
177
178/* jit.* functions. */
179static const luaL_Reg jitlib[] = {
180 { "on", j_on },
181 { "off", j_off },
182 { "debug", j_debug },
183 { "compile", j_compile },
184 { "compilesub", j_compilesub },
185 /* j_attach is added below. */
186 { NULL, NULL }
187};
188
189/* ------------------------------------------------------------------------ */
190
191/* Get the compiler pipeline table from an upvalue (j_attach, j_frontend). */
192#define COMPIPE lua_upvalueindex(1)
193
194/* Attach/detach handler to/from compiler pipeline. */
195static int j_attach(lua_State *L)
196{
197 int pipesz;
198 luaL_checktype(L, 1, LUA_TFUNCTION);
199 pipesz = lua_objlen(L, COMPIPE);
200 if (lua_isnoneornil(L, 2)) { /* Detach if no priority given. */
201 int i;
202 for (i = 1; i <= pipesz; i += 2) {
203 lua_rawgeti(L, COMPIPE, i);
204 if (lua_rawequal(L, 1, -1)) { /* Found: delete from pipeline. */
205 for (; i+2 <= pipesz; i++) { /* Shift down. */
206 lua_rawgeti(L, COMPIPE, i+2);
207 lua_rawseti(L, COMPIPE, i);
208 }
209 /* Clear last two elements. */
210 lua_pushnil(L); lua_rawseti(L, COMPIPE, i);
211 lua_pushnil(L); lua_rawseti(L, COMPIPE, i+1);
212 return 0;
213 }
214 lua_pop(L, 1);
215 }
216 return 0; /* Not found: ignore detach request. */
217 } else { /* Attach if priority given. */
218 int prio = luaL_checkint(L, 2);
219 int pos, i;
220 for (pos = 2; pos <= pipesz; pos += 2) {
221 lua_rawgeti(L, COMPIPE, pos);
222 if (prio > (int)lua_tointeger(L, -1)) break; /* Insertion point found. */
223 lua_pop(L, 1);
224 }
225 for (i = pipesz+2; i > pos; i--) { /* Shift up. */
226 lua_rawgeti(L, COMPIPE, i-2);
227 lua_rawseti(L, COMPIPE, i);
228 }
229 /* Set handler and priority. */
230 lua_pushvalue(L, 1); lua_rawseti(L, COMPIPE, i-1);
231 lua_pushvalue(L, 2); lua_rawseti(L, COMPIPE, i);
232 return 0;
233 }
234}
235
236/* Compiler frontend. Runs in the compiler thread. */
237/* First and only arg is the compiler state table. */
238static int j_frontend(lua_State *L)
239{
240 int status = JIT_S_OK;
241 int pos;
242 /* Loop through all handlers in the compiler pipeline. */
243 for (pos = 1; ; pos += 2) {
244 if (status != JIT_S_OK) { /* Pending failure? */
245 int prio;
246 lua_rawgeti(L, COMPIPE, pos+1); /* Must check for odd/even priority. */
247 if (lua_isnil(L, -1)) break; /* End of pipeline. */
248 prio = (int)lua_tointeger(L, -1);
249 lua_pop(L, 1);
250 if ((prio & 1) == 0) continue; /* Skip handlers with even priority. */
251 }
252 /* Call handler with compiler state table and optional failure status. */
253 lua_rawgeti(L, COMPIPE, pos);
254 if (lua_isnil(L, -1)) break; /* End of pipeline. */
255 lua_pushvalue(L, 1);
256 if (status != JIT_S_OK)
257 lua_pushinteger(L, status);
258 lua_call(L, status ? 2 : 1, 1);
259 if (!lua_isnil(L, -1)) /* Remember failure status. */
260 status = (int)lua_tointeger(L, -1);
261 lua_pop(L, 1);
262 }
263 lua_pushinteger(L, status);
264 return 1;
265}
266
267/* Compiler frontend wrapper. */
268static int frontwrap(lua_State *L, Table *st)
269{
270 jit_State *J = G(L)->jit_state;
271 lua_State *JL;
272 int status;
273
274 /* Allocate compiler thread on demand. */
275 if (J->L == NULL) {
276 if (!lua_checkstack(L, 3)) return JIT_S_COMPILER_ERROR;
277 sethvalue(L, L->top++, st); /* Prevent GC of state table. */
278 lua_pushlightuserdata(L, (void *)&regkey_comthread);
279 /* Cannot use C stack, since it's deallocated early in Coco. */
280 /* But we don't need one -- the compiler thread never yields, anyway. */
281 J->L = lua_newthread(L);
282 lua_rawset(L, LUA_REGISTRYINDEX);
283 L->top--; /* Remove state table from this stack. */
284 }
285 JL = J->L;
286
287 /* Initialize compiler thread stack with frontend and state table. */
288 lua_settop(JL, 0);
289 lua_pushlightuserdata(JL, (void *)&regkey_frontend);
290 lua_rawget(JL, LUA_REGISTRYINDEX);
291 sethvalue(JL, JL->top, st);
292 JL->top++;
293
294 /* Start the frontend by resuming the compiler thread. */
295 if (lua_resume(JL, 1) != 0) { /* Failed? */
296 /* Note: LUA_YIELD is treated like any other error. */
297 J->L = NULL; /* Get a new thread next time. */
298 fprintf(stderr, "[LuaJIT frontend failed: %s]\n",
299 lua_isstring(JL, -1) ? lua_tostring(JL, -1) : "(unknown error)");
300 return JIT_S_COMPILER_ERROR;
301 }
302
303 /* Get status from terminated thread. */
304 status = (int)lua_tointeger(JL, -1);
305 lua_settop(JL, 0); /* Help the GC. */
306 return status;
307}
308
309/* Create the compiler pipeline and register it. */
310static void makepipeline(lua_State *L)
311{
312 lua_createtable(L, 20, 0); /* 10 handlers+priorities should be enough. */
313 lua_pushcfunction(L, luaJIT_backend);
314 lua_rawseti(L, -2, 1);
315 lua_pushinteger(L, 0); /* Fill in the backend at prio 0. */
316 lua_rawseti(L, -2, 2);
317
318 /* Store the compiler frontend in the registry. */
319 lua_pushlightuserdata(L, (void *)&regkey_frontend);
320 lua_pushvalue(L, -2); /* Pipeline table as upvalue. */
321 lua_pushcclosure(L, j_frontend, 1);
322 lua_rawset(L, LUA_REGISTRYINDEX);
323
324 /* Register the frontend wrapper. */
325 G(L)->jit_state->frontwrap = frontwrap;
326
327 /* Add jit.attach with the pipeline table as upvalue. */
328 lua_pushcclosure(L, j_attach, 1);
329 lua_setfield(L, -2, "attach"); /* "jit" table must be below. */
330}
331
332/* ------------------------------------------------------------------------ */
333
334/* Calculate total mcode size without mfm and only for active mcode blocks. */
335static size_t mcodesize(Proto *pt)
336{
337 jit_MCTrailer tr;
338 size_t sz = 0;
339 tr.mcode = (char *)pt->jit_mcode;
340 tr.sz = pt->jit_szmcode;
341 do {
342 jit_Mfm *mfm = JIT_MCMFM(tr.mcode, tr.sz);
343 if (sz != 0 && jit_mfm_ismain(mfm)) break; /* Stop at old main mfm. */
344 while (*mfm != JIT_MFM_STOP) mfm--; /* Search for end of mcode. */
345 sz += (char *)mfm-(char *)tr.mcode; /* Add size of mcode without mfm. */
346 memcpy((void *)&tr, JIT_MCTRAILER(tr.mcode, tr.sz), sizeof(jit_MCTrailer));
347 } while (tr.mcode != NULL);
348 return sz;
349}
350
351#define setintfield(name, i) \
352 do { lua_pushinteger(L, i); lua_setfield(L, -2, name); } while (0)
353
354/* local stats = jit.util.stats(func) */
355static int ju_stats(lua_State *L)
356{
357 if (!(L->top > L->base))
358 luaL_argerror(L, 1, "Lua function expected");
359 if (isLfunction(L->base)) {
360 Proto *pt = clvalue(L->base)->l.p;
361 lua_createtable(L, 0, 11);
362 setintfield("status", pt->jit_status);
363 setintfield("stackslots", pt->maxstacksize);
364 setintfield("params", pt->numparams);
365 setintfield("bytecodes", pt->sizecode);
366 setintfield("consts", pt->sizek);
367 setintfield("upvalues", pt->nups);
368 setintfield("subs", pt->sizep);
369 lua_pushboolean(L, pt->is_vararg);
370 lua_setfield(L, -2, "isvararg");
371 lua_getfenv(L, 1);
372 lua_setfield(L, -2, "env");
373 if (pt->jit_szmcode != 0) {
374 setintfield("mcodesize", (int)mcodesize(pt));
375 lua_pushnumber(L, (lua_Number)(size_t)pt->jit_mcode);
376 lua_setfield(L, -2, "mcodeaddr");
377 }
378 return 1;
379 } else {
380 return 0; /* Don't throw an error like the other util functions. */
381 }
382}
383
384/* local op, a, b, c, test = jit.util.bytecode(func, pc) */
385static int ju_bytecode(lua_State *L)
386{
387 Proto *pt = check_LCL(L)->l.p;
388 int pc = luaL_checkint(L, 2);
389 if (pc >= 1 && pc <= pt->sizecode) {
390 Instruction ins = pt->code[pc-1];
391 OpCode op = GET_OPCODE(ins);
392 if (pc > 1 && (((int)OP_SETLIST) << POS_OP) ==
393 (pt->code[pc-2] & (MASK1(SIZE_OP,POS_OP) | MASK1(SIZE_C,POS_C)))) {
394 lua_pushstring(L, luaP_opnames[OP_SETLIST]);
395 lua_pushnumber(L, (lua_Number)ins); /* Fake extended op. */
396 return 1;
397 }
398 if (op >= NUM_OPCODES) return 0; /* Just in case. */
399 lua_pushstring(L, luaP_opnames[op]);
400 lua_pushinteger(L, GETARG_A(ins));
401 switch (getOpMode(op)) {
402 case iABC: {
403 int b = GETARG_B(ins), c = GETARG_C(ins);
404 switch (getBMode(op)) {
405 case OpArgN: lua_pushnil(L); break;
406 case OpArgK: if (ISK(b)) b = -1-INDEXK(b);
407 case OpArgR: case OpArgU: lua_pushinteger(L, b); break;
408 }
409 switch (getCMode(op)) {
410 case OpArgN: lua_pushnil(L); break;
411 case OpArgK: if (ISK(c)) c = -1-INDEXK(c);
412 case OpArgR: case OpArgU: lua_pushinteger(L, c); break;
413 }
414 lua_pushboolean(L, testTMode(op));
415 return 5;
416 }
417 case iABx: {
418 int bx = GETARG_Bx(ins);
419 lua_pushinteger(L, getBMode(op) == OpArgK ? -1-bx : bx);
420 return 3;
421 }
422 case iAsBx:
423 lua_pushinteger(L, GETARG_sBx(ins));
424 return 3;
425 }
426 }
427 return 0;
428}
429
430/* local const, ok = jit.util.const(func, idx) */
431static int ju_const(lua_State *L)
432{
433 Proto *pt = check_LCL(L)->l.p;
434 int idx = luaL_checkint(L, 2);
435 if (idx < 0) idx = -idx; /* Handle both positive and negative indices. */
436 if (idx >= 1 && idx <= pt->sizek) {
437 setobj2s(L, L->top-1, &pt->k[idx-1]);
438 lua_pushboolean(L, 1);
439 return 2;
440 }
441 lua_pushnil(L);
442 lua_pushboolean(L, 0);
443 return 2;
444}
445
446/* local upvalue, ok = jit.util.upvalue(func, idx) */
447static int ju_upvalue(lua_State *L)
448{
449 Closure *cl = check_LCL(L);
450 Proto *pt = cl->l.p;
451 int idx = luaL_checkint(L, 2);
452 if (idx >= 0 && idx < pt->nups) {
453 setobj2s(L, L->top-1, cl->l.upvals[idx]->v);
454 lua_pushboolean(L, 1);
455 return 2;
456 }
457 lua_pushnil(L);
458 lua_pushboolean(L, 0);
459 return 2;
460}
461
462/* local nup = jit.util.closurenup(func, idx) */
463static int ju_closurenup(lua_State *L)
464{
465 Closure *cl = check_LCL(L);
466 Proto *pt = cl->l.p;
467 int idx = luaL_checkint(L, 2);
468 if (idx >= 0 && idx < pt->sizep) {
469 lua_pushinteger(L, pt->p[idx]->nups);
470 return 1;
471 }
472 return 0;
473}
474
475/* for tag, mark in mfmiter do ... end. */
476static int ju_mfmiter(lua_State *L)
477{
478 jit_Mfm *mfm = (jit_Mfm *)lua_touserdata(L, lua_upvalueindex(1));
479 int m = *mfm--;
480 switch (m) {
481 case JIT_MFM_STOP: return 0;
482 case JIT_MFM_COMBINE: lua_pushliteral(L, "COMBINE"); lua_pushnil(L); break;
483 case JIT_MFM_DEAD: lua_pushliteral(L, "DEAD"); lua_pushnil(L); break;
484 default:
485 lua_pushinteger(L, m & JIT_MFM_MASK);
486 lua_pushboolean(L, m & JIT_MFM_MARK);
487 break;
488 }
489 lua_pushlightuserdata(L, (void *)mfm);
490 lua_replace(L, lua_upvalueindex(1));
491 return 2;
492}
493
494/* local addr, mcode, mfmiter = jit.util.mcode(func, block) */
495static int ju_mcode(lua_State *L)
496{
497 Proto *pt = check_LCL(L)->l.p;
498 if (pt->jit_szmcode == 0) { /* Not compiled (yet): return nil, status. */
499 lua_pushnil(L);
500 lua_pushinteger(L, pt->jit_status);
501 return 2;
502 } else {
503 jit_Mfm *mfm;
504 jit_MCTrailer tr;
505 int block = luaL_checkint(L, 2);
506 tr.mcode = (char *)pt->jit_mcode;
507 tr.sz = pt->jit_szmcode;
508 while (--block > 0) {
509 void *trp = JIT_MCTRAILER(tr.mcode, tr.sz);
510 memcpy((void *)&tr, trp, sizeof(jit_MCTrailer));
511 if (tr.sz == 0) return 0;
512 }
513 mfm = JIT_MCMFM(tr.mcode, tr.sz);
514 while (*mfm != JIT_MFM_STOP) mfm--; /* Search for end of mcode. */
515 lua_pushnumber(L, (lua_Number)(size_t)tr.mcode);
516 lua_pushlstring(L, (const char *)tr.mcode, (char *)mfm-(char *)tr.mcode);
517 lua_pushlightuserdata(L, (void *)JIT_MCMFM(tr.mcode, tr.sz));
518 lua_pushvalue(L, 1); /* Must hold onto function to avoid GC. */
519 lua_pushcclosure(L, ju_mfmiter, 2);
520 return 3;
521 }
522}
523
524/* local addr [, mcode] = jit.util.jsubmcode([idx]) */
525static int ju_jsubmcode(lua_State *L)
526{
527 jit_State *J = G(L)->jit_state;
528 if (lua_isnoneornil(L, 1)) {
529 lua_pushnumber(L, (lua_Number)(size_t)J->jsubmcode);
530 lua_pushlstring(L, (const char *)J->jsubmcode, J->szjsubmcode);
531 return 2;
532 } else {
533 int idx = luaL_checkint(L, 1);
534 if (idx >= 0 && idx < J->numjsub) {
535 lua_pushnumber(L, (lua_Number)(size_t)J->jsub[idx]);
536 return 1;
537 }
538 return 0;
539 }
540}
541
542/* FOR INTERNAL DEBUGGING USE ONLY: local addr = jit.util.stackptr() */
543static int ju_stackptr(lua_State *L)
544{
545 jit_State *J = G(L)->jit_state;
546 size_t addr = cast(size_t (*)(void), J->jsub[0])(); /* JSUB_STACKPTR == 0! */
547 lua_pushnumber(L, (lua_Number)addr);
548 return 1;
549}
550
551/* jit.util.* functions. */
552static const luaL_Reg jitutillib[] = {
553 {"stats", ju_stats },
554 {"bytecode", ju_bytecode },
555 {"const", ju_const },
556 {"upvalue", ju_upvalue },
557 {"closurenup", ju_closurenup },
558 {"mcode", ju_mcode },
559 {"jsubmcode", ju_jsubmcode },
560 {"stackptr", ju_stackptr },
561 { NULL, NULL }
562};
563
564/* Make hint name to hint number map. */
565static void makehints(lua_State *L, const char *const *t, int tmax,
566 const char *name)
567{
568 int i;
569 lua_createtable(L, 0, tmax);
570 for (i = 1; i < tmax; i++) {
571 lua_pushinteger(L, JIT_H2NUM(i));
572 lua_setfield(L, -2, t[i-1]);
573 }
574 lua_setfield(L, -2, name);
575}
576
577/* CHECK: must match with ljit.h (grep "ORDER JIT_S"). */
578static const char *const status_list[] = {
579 "OK",
580 "NONE",
581 "OFF",
582 "ENGINE_OFF",
583 "DELAYED",
584 "TOOLARGE",
585 "COMPILER_ERROR",
586 "DASM_ERROR"
587};
588
589/* Make bidirectional status name to status number map. */
590static void makestatus(lua_State *L, const char *name)
591{
592 int i;
593 lua_createtable(L, JIT_S_MAX-1, JIT_S_MAX+1); /* Codes are not 1-based. */
594 for (i = 0; i < JIT_S_MAX; i++) {
595 lua_pushstring(L, status_list[i]);
596 lua_pushinteger(L, i);
597 lua_pushvalue(L, -2);
598 lua_rawseti(L, -4, i);
599 lua_rawset(L, -3);
600 }
601 lua_setfield(L, -2, name);
602}
603
604/* ------------------------------------------------------------------------ */
605
606/*
607** Open JIT library
608*/
609LUALIB_API int luaopen_jit(lua_State *L)
610{
611 /* Add the core JIT library. */
612 luaL_register(L, LUA_JITLIBNAME, jitlib);
613 lua_pushliteral(L, LUAJIT_VERSION);
614 lua_setfield(L, -2, "version");
615 setintfield("version_num", LUAJIT_VERSION_NUM);
616 lua_pushstring(L, luaJIT_arch);
617 lua_setfield(L, -2, "arch");
618 makepipeline(L);
619
620 /* Add the utility JIT library. */
621 luaL_register(L, LUA_JITLIBNAME ".util", jitutillib);
622 makestatus(L, "status");
623 makehints(L, hints_H, JIT_H_MAX, "hints");
624 makehints(L, hints_FH, JIT_FH_MAX, "fhints");
625 lua_pop(L, 1);
626
627 /* Everything ok, so turn the JIT engine on. Vroooom! */
628 if (luaJIT_setmode(L, 0, LUAJIT_MODE_ENGINE|LUAJIT_MODE_ON) <= 0) {
629 /* Ouch. Someone screwed up DynASM or the JSUBs. Probably me. */
630 /* But if you get 999999999, look at jit_consistency_check(). */
631 return luaL_error(L, "JIT engine init failed (%d)",
632 G(L)->jit_state->dasmstatus);
633 }
634
635 return 1;
636}
637
diff --git a/libraries/LuaJIT-1.1.7/src/llex.c b/libraries/LuaJIT-1.1.7/src/llex.c
new file mode 100644
index 0000000..92d6575
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/llex.c
@@ -0,0 +1,463 @@
1/*
2** $Id: llex.c,v 2.20.1.1 2007/12/27 13:02:25 roberto Exp $
3** Lexical Analyzer
4** See Copyright Notice in lua.h
5*/
6
7
8#include <ctype.h>
9#include <locale.h>
10#include <string.h>
11
12#define llex_c
13#define LUA_CORE
14
15#include "lua.h"
16
17#include "ldo.h"
18#include "llex.h"
19#include "lobject.h"
20#include "lparser.h"
21#include "lstate.h"
22#include "lstring.h"
23#include "ltable.h"
24#include "lzio.h"
25
26
27
28#define next(ls) (ls->current = zgetc(ls->z))
29
30
31
32
33#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r')
34
35
36/* ORDER RESERVED */
37const char *const luaX_tokens [] = {
38 "and", "break", "do", "else", "elseif",
39 "end", "false", "for", "function", "if",
40 "in", "local", "nil", "not", "or", "repeat",
41 "return", "then", "true", "until", "while",
42 "..", "...", "==", ">=", "<=", "~=",
43 "<number>", "<name>", "<string>", "<eof>",
44 NULL
45};
46
47
48#define save_and_next(ls) (save(ls, ls->current), next(ls))
49
50
51static void save (LexState *ls, int c) {
52 Mbuffer *b = ls->buff;
53 if (b->n + 1 > b->buffsize) {
54 size_t newsize;
55 if (b->buffsize >= MAX_SIZET/2)
56 luaX_lexerror(ls, "lexical element too long", 0);
57 newsize = b->buffsize * 2;
58 luaZ_resizebuffer(ls->L, b, newsize);
59 }
60 b->buffer[b->n++] = cast(char, c);
61}
62
63
64void luaX_init (lua_State *L) {
65 int i;
66 for (i=0; i<NUM_RESERVED; i++) {
67 TString *ts = luaS_new(L, luaX_tokens[i]);
68 luaS_fix(ts); /* reserved words are never collected */
69 lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
70 ts->tsv.reserved = cast_byte(i+1); /* reserved word */
71 }
72}
73
74
75#define MAXSRC 80
76
77
78const char *luaX_token2str (LexState *ls, int token) {
79 if (token < FIRST_RESERVED) {
80 lua_assert(token == cast(unsigned char, token));
81 return (iscntrl(token)) ? luaO_pushfstring(ls->L, "char(%d)", token) :
82 luaO_pushfstring(ls->L, "%c", token);
83 }
84 else
85 return luaX_tokens[token-FIRST_RESERVED];
86}
87
88
89static const char *txtToken (LexState *ls, int token) {
90 switch (token) {
91 case TK_NAME:
92 case TK_STRING:
93 case TK_NUMBER:
94 save(ls, '\0');
95 return luaZ_buffer(ls->buff);
96 default:
97 return luaX_token2str(ls, token);
98 }
99}
100
101
102void luaX_lexerror (LexState *ls, const char *msg, int token) {
103 char buff[MAXSRC];
104 luaO_chunkid(buff, getstr(ls->source), MAXSRC);
105 msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
106 if (token)
107 luaO_pushfstring(ls->L, "%s near " LUA_QS, msg, txtToken(ls, token));
108 luaD_throw(ls->L, LUA_ERRSYNTAX);
109}
110
111
112void luaX_syntaxerror (LexState *ls, const char *msg) {
113 luaX_lexerror(ls, msg, ls->t.token);
114}
115
116
117TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
118 lua_State *L = ls->L;
119 TString *ts = luaS_newlstr(L, str, l);
120 TValue *o = luaH_setstr(L, ls->fs->h, ts); /* entry for `str' */
121 if (ttisnil(o)) {
122 setbvalue(o, 1); /* make sure `str' will not be collected */
123 luaC_checkGC(L);
124 }
125 return ts;
126}
127
128
129static void inclinenumber (LexState *ls) {
130 int old = ls->current;
131 lua_assert(currIsNewline(ls));
132 next(ls); /* skip `\n' or `\r' */
133 if (currIsNewline(ls) && ls->current != old)
134 next(ls); /* skip `\n\r' or `\r\n' */
135 if (++ls->linenumber >= MAX_INT)
136 luaX_syntaxerror(ls, "chunk has too many lines");
137}
138
139
140void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
141 ls->decpoint = '.';
142 ls->L = L;
143 ls->lookahead.token = TK_EOS; /* no look-ahead token */
144 ls->z = z;
145 ls->fs = NULL;
146 ls->linenumber = 1;
147 ls->lastline = 1;
148 ls->source = source;
149 luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */
150 next(ls); /* read first char */
151}
152
153
154
155/*
156** =======================================================
157** LEXICAL ANALYZER
158** =======================================================
159*/
160
161
162
163static int check_next (LexState *ls, const char *set) {
164 if (!strchr(set, ls->current))
165 return 0;
166 save_and_next(ls);
167 return 1;
168}
169
170
171static void buffreplace (LexState *ls, char from, char to) {
172 size_t n = luaZ_bufflen(ls->buff);
173 char *p = luaZ_buffer(ls->buff);
174 while (n--)
175 if (p[n] == from) p[n] = to;
176}
177
178
179static void trydecpoint (LexState *ls, SemInfo *seminfo) {
180 /* format error: try to update decimal point separator */
181 struct lconv *cv = localeconv();
182 char old = ls->decpoint;
183 ls->decpoint = (cv ? cv->decimal_point[0] : '.');
184 buffreplace(ls, old, ls->decpoint); /* try updated decimal separator */
185 if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) {
186 /* format error with correct decimal point: no more options */
187 buffreplace(ls, ls->decpoint, '.'); /* undo change (for error message) */
188 luaX_lexerror(ls, "malformed number", TK_NUMBER);
189 }
190}
191
192
193/* LUA_NUMBER */
194static void read_numeral (LexState *ls, SemInfo *seminfo) {
195 lua_assert(isdigit(ls->current));
196 do {
197 save_and_next(ls);
198 } while (isdigit(ls->current) || ls->current == '.');
199 if (check_next(ls, "Ee")) /* `E'? */
200 check_next(ls, "+-"); /* optional exponent sign */
201 while (isalnum(ls->current) || ls->current == '_')
202 save_and_next(ls);
203 save(ls, '\0');
204 buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */
205 if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) /* format error? */
206 trydecpoint(ls, seminfo); /* try to update decimal point separator */
207}
208
209
210static int skip_sep (LexState *ls) {
211 int count = 0;
212 int s = ls->current;
213 lua_assert(s == '[' || s == ']');
214 save_and_next(ls);
215 while (ls->current == '=') {
216 save_and_next(ls);
217 count++;
218 }
219 return (ls->current == s) ? count : (-count) - 1;
220}
221
222
223static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
224 int cont = 0;
225 (void)(cont); /* avoid warnings when `cont' is not used */
226 save_and_next(ls); /* skip 2nd `[' */
227 if (currIsNewline(ls)) /* string starts with a newline? */
228 inclinenumber(ls); /* skip it */
229 for (;;) {
230 switch (ls->current) {
231 case EOZ:
232 luaX_lexerror(ls, (seminfo) ? "unfinished long string" :
233 "unfinished long comment", TK_EOS);
234 break; /* to avoid warnings */
235#if defined(LUA_COMPAT_LSTR)
236 case '[': {
237 if (skip_sep(ls) == sep) {
238 save_and_next(ls); /* skip 2nd `[' */
239 cont++;
240#if LUA_COMPAT_LSTR == 1
241 if (sep == 0)
242 luaX_lexerror(ls, "nesting of [[...]] is deprecated", '[');
243#endif
244 }
245 break;
246 }
247#endif
248 case ']': {
249 if (skip_sep(ls) == sep) {
250 save_and_next(ls); /* skip 2nd `]' */
251#if defined(LUA_COMPAT_LSTR) && LUA_COMPAT_LSTR == 2
252 cont--;
253 if (sep == 0 && cont >= 0) break;
254#endif
255 goto endloop;
256 }
257 break;
258 }
259 case '\n':
260 case '\r': {
261 save(ls, '\n');
262 inclinenumber(ls);
263 if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */
264 break;
265 }
266 default: {
267 if (seminfo) save_and_next(ls);
268 else next(ls);
269 }
270 }
271 } endloop:
272 if (seminfo)
273 seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
274 luaZ_bufflen(ls->buff) - 2*(2 + sep));
275}
276
277
278static void read_string (LexState *ls, int del, SemInfo *seminfo) {
279 save_and_next(ls);
280 while (ls->current != del) {
281 switch (ls->current) {
282 case EOZ:
283 luaX_lexerror(ls, "unfinished string", TK_EOS);
284 continue; /* to avoid warnings */
285 case '\n':
286 case '\r':
287 luaX_lexerror(ls, "unfinished string", TK_STRING);
288 continue; /* to avoid warnings */
289 case '\\': {
290 int c;
291 next(ls); /* do not save the `\' */
292 switch (ls->current) {
293 case 'a': c = '\a'; break;
294 case 'b': c = '\b'; break;
295 case 'f': c = '\f'; break;
296 case 'n': c = '\n'; break;
297 case 'r': c = '\r'; break;
298 case 't': c = '\t'; break;
299 case 'v': c = '\v'; break;
300 case '\n': /* go through */
301 case '\r': save(ls, '\n'); inclinenumber(ls); continue;
302 case EOZ: continue; /* will raise an error next loop */
303 default: {
304 if (!isdigit(ls->current))
305 save_and_next(ls); /* handles \\, \", \', and \? */
306 else { /* \xxx */
307 int i = 0;
308 c = 0;
309 do {
310 c = 10*c + (ls->current-'0');
311 next(ls);
312 } while (++i<3 && isdigit(ls->current));
313 if (c > UCHAR_MAX)
314 luaX_lexerror(ls, "escape sequence too large", TK_STRING);
315 save(ls, c);
316 }
317 continue;
318 }
319 }
320 save(ls, c);
321 next(ls);
322 continue;
323 }
324 default:
325 save_and_next(ls);
326 }
327 }
328 save_and_next(ls); /* skip delimiter */
329 seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
330 luaZ_bufflen(ls->buff) - 2);
331}
332
333
334static int llex (LexState *ls, SemInfo *seminfo) {
335 luaZ_resetbuffer(ls->buff);
336 for (;;) {
337 switch (ls->current) {
338 case '\n':
339 case '\r': {
340 inclinenumber(ls);
341 continue;
342 }
343 case '-': {
344 next(ls);
345 if (ls->current != '-') return '-';
346 /* else is a comment */
347 next(ls);
348 if (ls->current == '[') {
349 int sep = skip_sep(ls);
350 luaZ_resetbuffer(ls->buff); /* `skip_sep' may dirty the buffer */
351 if (sep >= 0) {
352 read_long_string(ls, NULL, sep); /* long comment */
353 luaZ_resetbuffer(ls->buff);
354 continue;
355 }
356 }
357 /* else short comment */
358 while (!currIsNewline(ls) && ls->current != EOZ)
359 next(ls);
360 continue;
361 }
362 case '[': {
363 int sep = skip_sep(ls);
364 if (sep >= 0) {
365 read_long_string(ls, seminfo, sep);
366 return TK_STRING;
367 }
368 else if (sep == -1) return '[';
369 else luaX_lexerror(ls, "invalid long string delimiter", TK_STRING);
370 }
371 case '=': {
372 next(ls);
373 if (ls->current != '=') return '=';
374 else { next(ls); return TK_EQ; }
375 }
376 case '<': {
377 next(ls);
378 if (ls->current != '=') return '<';
379 else { next(ls); return TK_LE; }
380 }
381 case '>': {
382 next(ls);
383 if (ls->current != '=') return '>';
384 else { next(ls); return TK_GE; }
385 }
386 case '~': {
387 next(ls);
388 if (ls->current != '=') return '~';
389 else { next(ls); return TK_NE; }
390 }
391 case '"':
392 case '\'': {
393 read_string(ls, ls->current, seminfo);
394 return TK_STRING;
395 }
396 case '.': {
397 save_and_next(ls);
398 if (check_next(ls, ".")) {
399 if (check_next(ls, "."))
400 return TK_DOTS; /* ... */
401 else return TK_CONCAT; /* .. */
402 }
403 else if (!isdigit(ls->current)) return '.';
404 else {
405 read_numeral(ls, seminfo);
406 return TK_NUMBER;
407 }
408 }
409 case EOZ: {
410 return TK_EOS;
411 }
412 default: {
413 if (isspace(ls->current)) {
414 lua_assert(!currIsNewline(ls));
415 next(ls);
416 continue;
417 }
418 else if (isdigit(ls->current)) {
419 read_numeral(ls, seminfo);
420 return TK_NUMBER;
421 }
422 else if (isalpha(ls->current) || ls->current == '_') {
423 /* identifier or reserved word */
424 TString *ts;
425 do {
426 save_and_next(ls);
427 } while (isalnum(ls->current) || ls->current == '_');
428 ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
429 luaZ_bufflen(ls->buff));
430 if (ts->tsv.reserved > 0) /* reserved word? */
431 return ts->tsv.reserved - 1 + FIRST_RESERVED;
432 else {
433 seminfo->ts = ts;
434 return TK_NAME;
435 }
436 }
437 else {
438 int c = ls->current;
439 next(ls);
440 return c; /* single-char tokens (+ - / ...) */
441 }
442 }
443 }
444 }
445}
446
447
448void luaX_next (LexState *ls) {
449 ls->lastline = ls->linenumber;
450 if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */
451 ls->t = ls->lookahead; /* use this one */
452 ls->lookahead.token = TK_EOS; /* and discharge it */
453 }
454 else
455 ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */
456}
457
458
459void luaX_lookahead (LexState *ls) {
460 lua_assert(ls->lookahead.token == TK_EOS);
461 ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
462}
463
diff --git a/libraries/LuaJIT-1.1.7/src/llex.h b/libraries/LuaJIT-1.1.7/src/llex.h
new file mode 100644
index 0000000..a9201ce
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/llex.h
@@ -0,0 +1,81 @@
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*/
24enum 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' */
40LUAI_DATA const char *const luaX_tokens [];
41
42
43typedef union {
44 lua_Number r;
45 TString *ts;
46} SemInfo; /* semantics information */
47
48
49typedef struct Token {
50 int token;
51 SemInfo seminfo;
52} Token;
53
54
55typedef 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
70LUAI_FUNC void luaX_init (lua_State *L);
71LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
72 TString *source);
73LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
74LUAI_FUNC void luaX_next (LexState *ls);
75LUAI_FUNC void luaX_lookahead (LexState *ls);
76LUAI_FUNC void luaX_lexerror (LexState *ls, const char *msg, int token);
77LUAI_FUNC void luaX_syntaxerror (LexState *ls, const char *s);
78LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
79
80
81#endif
diff --git a/libraries/LuaJIT-1.1.7/src/llimits.h b/libraries/LuaJIT-1.1.7/src/llimits.h
new file mode 100644
index 0000000..ca8dcb7
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/llimits.h
@@ -0,0 +1,128 @@
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
18typedef LUAI_UINT32 lu_int32;
19
20typedef LUAI_UMEM lu_mem;
21
22typedef LUAI_MEM l_mem;
23
24
25
26/* chars used as small naturals (so that `char' is reserved for characters) */
27typedef 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 */
47typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
48
49
50/* result of a `usual argument conversion' over lua_Number */
51typedef 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*/
88typedef 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
diff --git a/libraries/LuaJIT-1.1.7/src/lmathlib.c b/libraries/LuaJIT-1.1.7/src/lmathlib.c
new file mode 100644
index 0000000..441fbf7
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lmathlib.c
@@ -0,0 +1,263 @@
1/*
2** $Id: lmathlib.c,v 1.67.1.1 2007/12/27 13:02:25 roberto Exp $
3** Standard mathematical library
4** See Copyright Notice in lua.h
5*/
6
7
8#include <stdlib.h>
9#include <math.h>
10
11#define lmathlib_c
12#define LUA_LIB
13
14#include "lua.h"
15
16#include "lauxlib.h"
17#include "lualib.h"
18
19
20#undef PI
21#define PI (3.14159265358979323846)
22#define RADIANS_PER_DEGREE (PI/180.0)
23
24
25
26static int math_abs (lua_State *L) {
27 lua_pushnumber(L, fabs(luaL_checknumber(L, 1)));
28 return 1;
29}
30
31static int math_sin (lua_State *L) {
32 lua_pushnumber(L, sin(luaL_checknumber(L, 1)));
33 return 1;
34}
35
36static int math_sinh (lua_State *L) {
37 lua_pushnumber(L, sinh(luaL_checknumber(L, 1)));
38 return 1;
39}
40
41static int math_cos (lua_State *L) {
42 lua_pushnumber(L, cos(luaL_checknumber(L, 1)));
43 return 1;
44}
45
46static int math_cosh (lua_State *L) {
47 lua_pushnumber(L, cosh(luaL_checknumber(L, 1)));
48 return 1;
49}
50
51static int math_tan (lua_State *L) {
52 lua_pushnumber(L, tan(luaL_checknumber(L, 1)));
53 return 1;
54}
55
56static int math_tanh (lua_State *L) {
57 lua_pushnumber(L, tanh(luaL_checknumber(L, 1)));
58 return 1;
59}
60
61static int math_asin (lua_State *L) {
62 lua_pushnumber(L, asin(luaL_checknumber(L, 1)));
63 return 1;
64}
65
66static int math_acos (lua_State *L) {
67 lua_pushnumber(L, acos(luaL_checknumber(L, 1)));
68 return 1;
69}
70
71static int math_atan (lua_State *L) {
72 lua_pushnumber(L, atan(luaL_checknumber(L, 1)));
73 return 1;
74}
75
76static int math_atan2 (lua_State *L) {
77 lua_pushnumber(L, atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
78 return 1;
79}
80
81static int math_ceil (lua_State *L) {
82 lua_pushnumber(L, ceil(luaL_checknumber(L, 1)));
83 return 1;
84}
85
86static int math_floor (lua_State *L) {
87 lua_pushnumber(L, floor(luaL_checknumber(L, 1)));
88 return 1;
89}
90
91static int math_fmod (lua_State *L) {
92 lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
93 return 1;
94}
95
96static int math_modf (lua_State *L) {
97 double ip;
98 double fp = modf(luaL_checknumber(L, 1), &ip);
99 lua_pushnumber(L, ip);
100 lua_pushnumber(L, fp);
101 return 2;
102}
103
104static int math_sqrt (lua_State *L) {
105 lua_pushnumber(L, sqrt(luaL_checknumber(L, 1)));
106 return 1;
107}
108
109static int math_pow (lua_State *L) {
110 lua_pushnumber(L, pow(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
111 return 1;
112}
113
114static int math_log (lua_State *L) {
115 lua_pushnumber(L, log(luaL_checknumber(L, 1)));
116 return 1;
117}
118
119static int math_log10 (lua_State *L) {
120 lua_pushnumber(L, log10(luaL_checknumber(L, 1)));
121 return 1;
122}
123
124static int math_exp (lua_State *L) {
125 lua_pushnumber(L, exp(luaL_checknumber(L, 1)));
126 return 1;
127}
128
129static int math_deg (lua_State *L) {
130 lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE);
131 return 1;
132}
133
134static int math_rad (lua_State *L) {
135 lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);
136 return 1;
137}
138
139static int math_frexp (lua_State *L) {
140 int e;
141 lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
142 lua_pushinteger(L, e);
143 return 2;
144}
145
146static int math_ldexp (lua_State *L) {
147 lua_pushnumber(L, ldexp(luaL_checknumber(L, 1), luaL_checkint(L, 2)));
148 return 1;
149}
150
151
152
153static int math_min (lua_State *L) {
154 int n = lua_gettop(L); /* number of arguments */
155 lua_Number dmin = luaL_checknumber(L, 1);
156 int i;
157 for (i=2; i<=n; i++) {
158 lua_Number d = luaL_checknumber(L, i);
159 if (d < dmin)
160 dmin = d;
161 }
162 lua_pushnumber(L, dmin);
163 return 1;
164}
165
166
167static int math_max (lua_State *L) {
168 int n = lua_gettop(L); /* number of arguments */
169 lua_Number dmax = luaL_checknumber(L, 1);
170 int i;
171 for (i=2; i<=n; i++) {
172 lua_Number d = luaL_checknumber(L, i);
173 if (d > dmax)
174 dmax = d;
175 }
176 lua_pushnumber(L, dmax);
177 return 1;
178}
179
180
181static int math_random (lua_State *L) {
182 /* the `%' avoids the (rare) case of r==1, and is needed also because on
183 some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
184 lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
185 switch (lua_gettop(L)) { /* check number of arguments */
186 case 0: { /* no arguments */
187 lua_pushnumber(L, r); /* Number between 0 and 1 */
188 break;
189 }
190 case 1: { /* only upper limit */
191 int u = luaL_checkint(L, 1);
192 luaL_argcheck(L, 1<=u, 1, "interval is empty");
193 lua_pushnumber(L, floor(r*u)+1); /* int between 1 and `u' */
194 break;
195 }
196 case 2: { /* lower and upper limits */
197 int l = luaL_checkint(L, 1);
198 int u = luaL_checkint(L, 2);
199 luaL_argcheck(L, l<=u, 2, "interval is empty");
200 lua_pushnumber(L, floor(r*(u-l+1))+l); /* int between `l' and `u' */
201 break;
202 }
203 default: return luaL_error(L, "wrong number of arguments");
204 }
205 return 1;
206}
207
208
209static int math_randomseed (lua_State *L) {
210 srand(luaL_checkint(L, 1));
211 return 0;
212}
213
214
215static const luaL_Reg mathlib[] = {
216 {"abs", math_abs},
217 {"acos", math_acos},
218 {"asin", math_asin},
219 {"atan2", math_atan2},
220 {"atan", math_atan},
221 {"ceil", math_ceil},
222 {"cosh", math_cosh},
223 {"cos", math_cos},
224 {"deg", math_deg},
225 {"exp", math_exp},
226 {"floor", math_floor},
227 {"fmod", math_fmod},
228 {"frexp", math_frexp},
229 {"ldexp", math_ldexp},
230 {"log10", math_log10},
231 {"log", math_log},
232 {"max", math_max},
233 {"min", math_min},
234 {"modf", math_modf},
235 {"pow", math_pow},
236 {"rad", math_rad},
237 {"random", math_random},
238 {"randomseed", math_randomseed},
239 {"sinh", math_sinh},
240 {"sin", math_sin},
241 {"sqrt", math_sqrt},
242 {"tanh", math_tanh},
243 {"tan", math_tan},
244 {NULL, NULL}
245};
246
247
248/*
249** Open math library
250*/
251LUALIB_API int luaopen_math (lua_State *L) {
252 luaL_register(L, LUA_MATHLIBNAME, mathlib);
253 lua_pushnumber(L, PI);
254 lua_setfield(L, -2, "pi");
255 lua_pushnumber(L, HUGE_VAL);
256 lua_setfield(L, -2, "huge");
257#if defined(LUA_COMPAT_MOD)
258 lua_getfield(L, -1, "fmod");
259 lua_setfield(L, -2, "mod");
260#endif
261 return 1;
262}
263
diff --git a/libraries/LuaJIT-1.1.7/src/lmem.c b/libraries/LuaJIT-1.1.7/src/lmem.c
new file mode 100644
index 0000000..ae7d8c9
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lmem.c
@@ -0,0 +1,86 @@
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
46void *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
66void *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*/
76void *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
diff --git a/libraries/LuaJIT-1.1.7/src/lmem.h b/libraries/LuaJIT-1.1.7/src/lmem.h
new file mode 100644
index 0000000..7c2dcb3
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lmem.h
@@ -0,0 +1,49 @@
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
41LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
42 size_t size);
43LUAI_FUNC void *luaM_toobig (lua_State *L);
44LUAI_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
diff --git a/libraries/LuaJIT-1.1.7/src/loadlib.c b/libraries/LuaJIT-1.1.7/src/loadlib.c
new file mode 100644
index 0000000..a2da9fc
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/loadlib.c
@@ -0,0 +1,669 @@
1/*
2** $Id: loadlib.c,v 1.52.1.3 2008/08/06 13:29:28 roberto Exp $
3** Dynamic library loader for Lua
4** See Copyright Notice in lua.h
5**
6** This module contains an implementation of loadlib for Unix systems
7** that have dlfcn, an implementation for Darwin (Mac OS X), an
8** implementation for Windows, and a stub for other systems.
9*/
10
11
12#include <stdlib.h>
13#include <string.h>
14
15
16#define loadlib_c
17#define LUA_LIB
18
19#include "lua.h"
20
21#include "lauxlib.h"
22#include "lualib.h"
23#include "luajit.h"
24
25
26/* prefix for open functions in C libraries */
27#define LUA_POF "luaopen_"
28
29/* separator for open functions in C libraries */
30#define LUA_OFSEP "_"
31
32
33#define LIBPREFIX "LOADLIB: "
34
35#define POF LUA_POF
36#define LIB_FAIL "open"
37
38
39/* error codes for ll_loadfunc */
40#define ERRLIB 1
41#define ERRFUNC 2
42
43#define setprogdir(L) ((void)0)
44
45
46static void ll_unloadlib (void *lib);
47static void *ll_load (lua_State *L, const char *path);
48static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym);
49
50
51
52#if defined(LUA_DL_DLOPEN)
53/*
54** {========================================================================
55** This is an implementation of loadlib based on the dlfcn interface.
56** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
57** NetBSD, AIX 4.2, HPUX 11, and probably most other Unix flavors, at least
58** as an emulation layer on top of native functions.
59** =========================================================================
60*/
61
62#include <dlfcn.h>
63
64static void ll_unloadlib (void *lib) {
65 dlclose(lib);
66}
67
68
69static void *ll_load (lua_State *L, const char *path) {
70 void *lib = dlopen(path, RTLD_NOW);
71 if (lib == NULL) lua_pushstring(L, dlerror());
72 return lib;
73}
74
75
76static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
77 lua_CFunction f = (lua_CFunction)dlsym(lib, sym);
78 if (f == NULL) lua_pushstring(L, dlerror());
79 return f;
80}
81
82/* }====================================================== */
83
84
85
86#elif defined(LUA_DL_DLL)
87/*
88** {======================================================================
89** This is an implementation of loadlib for Windows using native functions.
90** =======================================================================
91*/
92
93#include <windows.h>
94
95
96#undef setprogdir
97
98static void setprogdir (lua_State *L) {
99 char buff[MAX_PATH + 1];
100 char *lb;
101 DWORD nsize = sizeof(buff)/sizeof(char);
102 DWORD n = GetModuleFileNameA(NULL, buff, nsize);
103 if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
104 luaL_error(L, "unable to get ModuleFileName");
105 else {
106 *lb = '\0';
107 luaL_gsub(L, lua_tostring(L, -1), LUA_EXECDIR, buff);
108 lua_remove(L, -2); /* remove original string */
109 }
110}
111
112
113static void pusherror (lua_State *L) {
114 int error = GetLastError();
115 char buffer[128];
116 if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
117 NULL, error, 0, buffer, sizeof(buffer), NULL))
118 lua_pushstring(L, buffer);
119 else
120 lua_pushfstring(L, "system error %d\n", error);
121}
122
123static void ll_unloadlib (void *lib) {
124 FreeLibrary((HINSTANCE)lib);
125}
126
127
128static void *ll_load (lua_State *L, const char *path) {
129 HINSTANCE lib = LoadLibraryA(path);
130 if (lib == NULL) pusherror(L);
131 return lib;
132}
133
134
135static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
136 lua_CFunction f = (lua_CFunction)GetProcAddress((HINSTANCE)lib, sym);
137 if (f == NULL) pusherror(L);
138 return f;
139}
140
141/* }====================================================== */
142
143
144
145#elif defined(LUA_DL_DYLD)
146/*
147** {======================================================================
148** Native Mac OS X / Darwin Implementation
149** =======================================================================
150*/
151
152#include <mach-o/dyld.h>
153
154
155/* Mac appends a `_' before C function names */
156#undef POF
157#define POF "_" LUA_POF
158
159
160static void pusherror (lua_State *L) {
161 const char *err_str;
162 const char *err_file;
163 NSLinkEditErrors err;
164 int err_num;
165 NSLinkEditError(&err, &err_num, &err_file, &err_str);
166 lua_pushstring(L, err_str);
167}
168
169
170static const char *errorfromcode (NSObjectFileImageReturnCode ret) {
171 switch (ret) {
172 case NSObjectFileImageInappropriateFile:
173 return "file is not a bundle";
174 case NSObjectFileImageArch:
175 return "library is for wrong CPU type";
176 case NSObjectFileImageFormat:
177 return "bad format";
178 case NSObjectFileImageAccess:
179 return "cannot access file";
180 case NSObjectFileImageFailure:
181 default:
182 return "unable to load library";
183 }
184}
185
186
187static void ll_unloadlib (void *lib) {
188 NSUnLinkModule((NSModule)lib, NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES);
189}
190
191
192static void *ll_load (lua_State *L, const char *path) {
193 NSObjectFileImage img;
194 NSObjectFileImageReturnCode ret;
195 /* this would be a rare case, but prevents crashing if it happens */
196 if(!_dyld_present()) {
197 lua_pushliteral(L, "dyld not present");
198 return NULL;
199 }
200 ret = NSCreateObjectFileImageFromFile(path, &img);
201 if (ret == NSObjectFileImageSuccess) {
202 NSModule mod = NSLinkModule(img, path, NSLINKMODULE_OPTION_PRIVATE |
203 NSLINKMODULE_OPTION_RETURN_ON_ERROR);
204 NSDestroyObjectFileImage(img);
205 if (mod == NULL) pusherror(L);
206 return mod;
207 }
208 lua_pushstring(L, errorfromcode(ret));
209 return NULL;
210}
211
212
213static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
214 NSSymbol nss = NSLookupSymbolInModule((NSModule)lib, sym);
215 if (nss == NULL) {
216 lua_pushfstring(L, "symbol " LUA_QS " not found", sym);
217 return NULL;
218 }
219 return (lua_CFunction)NSAddressOfSymbol(nss);
220}
221
222/* }====================================================== */
223
224
225
226#else
227/*
228** {======================================================
229** Fallback for other systems
230** =======================================================
231*/
232
233#undef LIB_FAIL
234#define LIB_FAIL "absent"
235
236
237#define DLMSG "dynamic libraries not enabled; check your Lua installation"
238
239
240static void ll_unloadlib (void *lib) {
241 (void)lib; /* to avoid warnings */
242}
243
244
245static void *ll_load (lua_State *L, const char *path) {
246 (void)path; /* to avoid warnings */
247 lua_pushliteral(L, DLMSG);
248 return NULL;
249}
250
251
252static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
253 (void)lib; (void)sym; /* to avoid warnings */
254 lua_pushliteral(L, DLMSG);
255 return NULL;
256}
257
258/* }====================================================== */
259#endif
260
261
262
263static void **ll_register (lua_State *L, const char *path) {
264 void **plib;
265 lua_pushfstring(L, "%s%s", LIBPREFIX, path);
266 lua_gettable(L, LUA_REGISTRYINDEX); /* check library in registry? */
267 if (!lua_isnil(L, -1)) /* is there an entry? */
268 plib = (void **)lua_touserdata(L, -1);
269 else { /* no entry yet; create one */
270 lua_pop(L, 1);
271 plib = (void **)lua_newuserdata(L, sizeof(const void *));
272 *plib = NULL;
273 luaL_getmetatable(L, "_LOADLIB");
274 lua_setmetatable(L, -2);
275 lua_pushfstring(L, "%s%s", LIBPREFIX, path);
276 lua_pushvalue(L, -2);
277 lua_settable(L, LUA_REGISTRYINDEX);
278 }
279 return plib;
280}
281
282
283/*
284** __gc tag method: calls library's `ll_unloadlib' function with the lib
285** handle
286*/
287static int gctm (lua_State *L) {
288 void **lib = (void **)luaL_checkudata(L, 1, "_LOADLIB");
289 if (*lib) ll_unloadlib(*lib);
290 *lib = NULL; /* mark library as closed */
291 return 0;
292}
293
294
295static int ll_loadfunc (lua_State *L, const char *path, const char *sym) {
296 void **reg = ll_register(L, path);
297 if (*reg == NULL) *reg = ll_load(L, path);
298 if (*reg == NULL)
299 return ERRLIB; /* unable to load library */
300 else {
301 lua_CFunction f = ll_sym(L, *reg, sym);
302 if (f == NULL)
303 return ERRFUNC; /* unable to find function */
304 lua_pushcfunction(L, f);
305 return 0; /* return function */
306 }
307}
308
309
310static int ll_loadlib (lua_State *L) {
311 const char *path = luaL_checkstring(L, 1);
312 const char *init = luaL_checkstring(L, 2);
313 int stat = ll_loadfunc(L, path, init);
314 if (stat == 0) /* no errors? */
315 return 1; /* return the loaded function */
316 else { /* error; error message is on stack top */
317 lua_pushnil(L);
318 lua_insert(L, -2);
319 lua_pushstring(L, (stat == ERRLIB) ? LIB_FAIL : "init");
320 return 3; /* return nil, error message, and where */
321 }
322}
323
324
325
326/*
327** {======================================================
328** 'require' function
329** =======================================================
330*/
331
332
333static int readable (const char *filename) {
334 FILE *f = fopen(filename, "r"); /* try to open file */
335 if (f == NULL) return 0; /* open failed */
336 fclose(f);
337 return 1;
338}
339
340
341static const char *pushnexttemplate (lua_State *L, const char *path) {
342 const char *l;
343 while (*path == *LUA_PATHSEP) path++; /* skip separators */
344 if (*path == '\0') return NULL; /* no more templates */
345 l = strchr(path, *LUA_PATHSEP); /* find next separator */
346 if (l == NULL) l = path + strlen(path);
347 lua_pushlstring(L, path, l - path); /* template */
348 return l;
349}
350
351
352static const char *findfile (lua_State *L, const char *name,
353 const char *pname) {
354 const char *path;
355 name = luaL_gsub(L, name, ".", LUA_DIRSEP);
356 lua_getfield(L, LUA_ENVIRONINDEX, pname);
357 path = lua_tostring(L, -1);
358 if (path == NULL)
359 luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
360 lua_pushliteral(L, ""); /* error accumulator */
361 while ((path = pushnexttemplate(L, path)) != NULL) {
362 const char *filename;
363 filename = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);
364 lua_remove(L, -2); /* remove path template */
365 if (readable(filename)) /* does file exist and is readable? */
366 return filename; /* return that file name */
367 lua_pushfstring(L, "\n\tno file " LUA_QS, filename);
368 lua_remove(L, -2); /* remove file name */
369 lua_concat(L, 2); /* add entry to possible error message */
370 }
371 return NULL; /* not found */
372}
373
374
375static void loaderror (lua_State *L, const char *filename) {
376 luaL_error(L, "error loading module " LUA_QS " from file " LUA_QS ":\n\t%s",
377 lua_tostring(L, 1), filename, lua_tostring(L, -1));
378}
379
380
381static int loader_Lua (lua_State *L) {
382 const char *filename;
383 const char *name = luaL_checkstring(L, 1);
384 filename = findfile(L, name, "path");
385 if (filename == NULL) return 1; /* library not found in this path */
386 if (luaL_loadfile(L, filename) != 0)
387 loaderror(L, filename);
388 /* not useful to JIT compile main chunk of a module */
389 luaJIT_setmode(L, -1, LUAJIT_MODE_FUNC|LUAJIT_MODE_OFF);
390 return 1; /* library loaded successfully */
391}
392
393
394static const char *mkfuncname (lua_State *L, const char *modname) {
395 const char *funcname;
396 const char *mark = strchr(modname, *LUA_IGMARK);
397 if (mark) modname = mark + 1;
398 funcname = luaL_gsub(L, modname, ".", LUA_OFSEP);
399 funcname = lua_pushfstring(L, POF"%s", funcname);
400 lua_remove(L, -2); /* remove 'gsub' result */
401 return funcname;
402}
403
404
405static int loader_C (lua_State *L) {
406 const char *funcname;
407 const char *name = luaL_checkstring(L, 1);
408 const char *filename = findfile(L, name, "cpath");
409 if (filename == NULL) return 1; /* library not found in this path */
410 funcname = mkfuncname(L, name);
411 if (ll_loadfunc(L, filename, funcname) != 0)
412 loaderror(L, filename);
413 return 1; /* library loaded successfully */
414}
415
416
417static int loader_Croot (lua_State *L) {
418 const char *funcname;
419 const char *filename;
420 const char *name = luaL_checkstring(L, 1);
421 const char *p = strchr(name, '.');
422 int stat;
423 if (p == NULL) return 0; /* is root */
424 lua_pushlstring(L, name, p - name);
425 filename = findfile(L, lua_tostring(L, -1), "cpath");
426 if (filename == NULL) return 1; /* root not found */
427 funcname = mkfuncname(L, name);
428 if ((stat = ll_loadfunc(L, filename, funcname)) != 0) {
429 if (stat != ERRFUNC) loaderror(L, filename); /* real error */
430 lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS,
431 name, filename);
432 return 1; /* function not found */
433 }
434 return 1;
435}
436
437
438static int loader_preload (lua_State *L) {
439 const char *name = luaL_checkstring(L, 1);
440 lua_getfield(L, LUA_ENVIRONINDEX, "preload");
441 if (!lua_istable(L, -1))
442 luaL_error(L, LUA_QL("package.preload") " must be a table");
443 lua_getfield(L, -1, name);
444 if (lua_isnil(L, -1)) /* not found? */
445 lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
446 return 1;
447}
448
449
450static const int sentinel_ = 0;
451#define sentinel ((void *)&sentinel_)
452
453
454static int ll_require (lua_State *L) {
455 const char *name = luaL_checkstring(L, 1);
456 int i;
457 lua_settop(L, 1); /* _LOADED table will be at index 2 */
458 lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
459 lua_getfield(L, 2, name);
460 if (lua_toboolean(L, -1)) { /* is it there? */
461 if (lua_touserdata(L, -1) == sentinel) /* check loops */
462 luaL_error(L, "loop or previous error loading module " LUA_QS, name);
463 return 1; /* package is already loaded */
464 }
465 /* else must load it; iterate over available loaders */
466 lua_getfield(L, LUA_ENVIRONINDEX, "loaders");
467 if (!lua_istable(L, -1))
468 luaL_error(L, LUA_QL("package.loaders") " must be a table");
469 lua_pushliteral(L, ""); /* error message accumulator */
470 for (i=1; ; i++) {
471 lua_rawgeti(L, -2, i); /* get a loader */
472 if (lua_isnil(L, -1))
473 luaL_error(L, "module " LUA_QS " not found:%s",
474 name, lua_tostring(L, -2));
475 lua_pushstring(L, name);
476 lua_call(L, 1, 1); /* call it */
477 if (lua_isfunction(L, -1)) /* did it find module? */
478 break; /* module loaded successfully */
479 else if (lua_isstring(L, -1)) /* loader returned error message? */
480 lua_concat(L, 2); /* accumulate it */
481 else
482 lua_pop(L, 1);
483 }
484 lua_pushlightuserdata(L, sentinel);
485 lua_setfield(L, 2, name); /* _LOADED[name] = sentinel */
486 lua_pushstring(L, name); /* pass name as argument to module */
487 lua_call(L, 1, 1); /* run loaded module */
488 if (!lua_isnil(L, -1)) /* non-nil return? */
489 lua_setfield(L, 2, name); /* _LOADED[name] = returned value */
490 lua_getfield(L, 2, name);
491 if (lua_touserdata(L, -1) == sentinel) { /* module did not set a value? */
492 lua_pushboolean(L, 1); /* use true as result */
493 lua_pushvalue(L, -1); /* extra copy to be returned */
494 lua_setfield(L, 2, name); /* _LOADED[name] = true */
495 }
496 return 1;
497}
498
499/* }====================================================== */
500
501
502
503/*
504** {======================================================
505** 'module' function
506** =======================================================
507*/
508
509
510static void setfenv (lua_State *L) {
511 lua_Debug ar;
512 if (lua_getstack(L, 1, &ar) == 0 ||
513 lua_getinfo(L, "f", &ar) == 0 || /* get calling function */
514 lua_iscfunction(L, -1))
515 luaL_error(L, LUA_QL("module") " not called from a Lua function");
516 lua_pushvalue(L, -2);
517 lua_setfenv(L, -2);
518 lua_pop(L, 1);
519}
520
521
522static void dooptions (lua_State *L, int n) {
523 int i;
524 for (i = 2; i <= n; i++) {
525 lua_pushvalue(L, i); /* get option (a function) */
526 lua_pushvalue(L, -2); /* module */
527 lua_call(L, 1, 0);
528 }
529}
530
531
532static void modinit (lua_State *L, const char *modname) {
533 const char *dot;
534 lua_pushvalue(L, -1);
535 lua_setfield(L, -2, "_M"); /* module._M = module */
536 lua_pushstring(L, modname);
537 lua_setfield(L, -2, "_NAME");
538 dot = strrchr(modname, '.'); /* look for last dot in module name */
539 if (dot == NULL) dot = modname;
540 else dot++;
541 /* set _PACKAGE as package name (full module name minus last part) */
542 lua_pushlstring(L, modname, dot - modname);
543 lua_setfield(L, -2, "_PACKAGE");
544}
545
546
547static int ll_module (lua_State *L) {
548 const char *modname = luaL_checkstring(L, 1);
549 int loaded = lua_gettop(L) + 1; /* index of _LOADED table */
550 lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
551 lua_getfield(L, loaded, modname); /* get _LOADED[modname] */
552 if (!lua_istable(L, -1)) { /* not found? */
553 lua_pop(L, 1); /* remove previous result */
554 /* try global variable (and create one if it does not exist) */
555 if (luaL_findtable(L, LUA_GLOBALSINDEX, modname, 1) != NULL)
556 return luaL_error(L, "name conflict for module " LUA_QS, modname);
557 lua_pushvalue(L, -1);
558 lua_setfield(L, loaded, modname); /* _LOADED[modname] = new table */
559 }
560 /* check whether table already has a _NAME field */
561 lua_getfield(L, -1, "_NAME");
562 if (!lua_isnil(L, -1)) /* is table an initialized module? */
563 lua_pop(L, 1);
564 else { /* no; initialize it */
565 lua_pop(L, 1);
566 modinit(L, modname);
567 }
568 lua_pushvalue(L, -1);
569 setfenv(L);
570 dooptions(L, loaded - 1);
571 return 0;
572}
573
574
575static int ll_seeall (lua_State *L) {
576 luaL_checktype(L, 1, LUA_TTABLE);
577 if (!lua_getmetatable(L, 1)) {
578 lua_createtable(L, 0, 1); /* create new metatable */
579 lua_pushvalue(L, -1);
580 lua_setmetatable(L, 1);
581 }
582 lua_pushvalue(L, LUA_GLOBALSINDEX);
583 lua_setfield(L, -2, "__index"); /* mt.__index = _G */
584 return 0;
585}
586
587
588/* }====================================================== */
589
590
591
592/* auxiliary mark (for internal use) */
593#define AUXMARK "\1"
594
595static void setpath (lua_State *L, const char *fieldname, const char *envname,
596 const char *def) {
597 const char *path = getenv(envname);
598 if (path == NULL) /* no environment variable? */
599 lua_pushstring(L, def); /* use default */
600 else {
601 /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
602 path = luaL_gsub(L, path, LUA_PATHSEP LUA_PATHSEP,
603 LUA_PATHSEP AUXMARK LUA_PATHSEP);
604 luaL_gsub(L, path, AUXMARK, def);
605 lua_remove(L, -2);
606 }
607 setprogdir(L);
608 lua_setfield(L, -2, fieldname);
609}
610
611
612static const luaL_Reg pk_funcs[] = {
613 {"loadlib", ll_loadlib},
614 {"seeall", ll_seeall},
615 {NULL, NULL}
616};
617
618
619static const luaL_Reg ll_funcs[] = {
620 {"module", ll_module},
621 {"require", ll_require},
622 {NULL, NULL}
623};
624
625
626static const lua_CFunction loaders[] =
627 {loader_preload, loader_Lua, loader_C, loader_Croot, NULL};
628
629
630LUALIB_API int luaopen_package (lua_State *L) {
631 int i;
632 /* create new type _LOADLIB */
633 luaL_newmetatable(L, "_LOADLIB");
634 lua_pushcfunction(L, gctm);
635 lua_setfield(L, -2, "__gc");
636 /* create `package' table */
637 luaL_register(L, LUA_LOADLIBNAME, pk_funcs);
638#if defined(LUA_COMPAT_LOADLIB)
639 lua_getfield(L, -1, "loadlib");
640 lua_setfield(L, LUA_GLOBALSINDEX, "loadlib");
641#endif
642 lua_pushvalue(L, -1);
643 lua_replace(L, LUA_ENVIRONINDEX);
644 /* create `loaders' table */
645 lua_createtable(L, sizeof(loaders)/sizeof(loaders[0]) - 1, 0);
646 /* fill it with pre-defined loaders */
647 for (i=0; loaders[i] != NULL; i++) {
648 lua_pushcfunction(L, loaders[i]);
649 lua_rawseti(L, -2, i+1);
650 }
651 lua_setfield(L, -2, "loaders"); /* put it in field `loaders' */
652 setpath(L, "path", LUA_PATH, LUA_PATH_DEFAULT); /* set field `path' */
653 setpath(L, "cpath", LUA_CPATH, LUA_CPATH_DEFAULT); /* set field `cpath' */
654 /* store config information */
655 lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATHSEP "\n" LUA_PATH_MARK "\n"
656 LUA_EXECDIR "\n" LUA_IGMARK);
657 lua_setfield(L, -2, "config");
658 /* set field `loaded' */
659 luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 2);
660 lua_setfield(L, -2, "loaded");
661 /* set field `preload' */
662 lua_newtable(L);
663 lua_setfield(L, -2, "preload");
664 lua_pushvalue(L, LUA_GLOBALSINDEX);
665 luaL_register(L, NULL, ll_funcs); /* open lib into global table */
666 lua_pop(L, 1);
667 return 1; /* return 'package' table */
668}
669
diff --git a/libraries/LuaJIT-1.1.7/src/lobject.c b/libraries/LuaJIT-1.1.7/src/lobject.c
new file mode 100644
index 0000000..4ff5073
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lobject.c
@@ -0,0 +1,214 @@
1/*
2** $Id: lobject.c,v 2.22.1.1 2007/12/27 13:02:25 roberto Exp $
3** Some generic functions over Lua objects
4** See Copyright Notice in lua.h
5*/
6
7#include <ctype.h>
8#include <stdarg.h>
9#include <stdio.h>
10#include <stdlib.h>
11#include <string.h>
12
13#define lobject_c
14#define LUA_CORE
15
16#include "lua.h"
17
18#include "ldo.h"
19#include "lmem.h"
20#include "lobject.h"
21#include "lstate.h"
22#include "lstring.h"
23#include "lvm.h"
24
25
26
27const TValue luaO_nilobject_ = {{NULL}, LUA_TNIL};
28
29
30/*
31** converts an integer to a "floating point byte", represented as
32** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if
33** eeeee != 0 and (xxx) otherwise.
34*/
35int luaO_int2fb (unsigned int x) {
36 int e = 0; /* expoent */
37 while (x >= 16) {
38 x = (x+1) >> 1;
39 e++;
40 }
41 if (x < 8) return x;
42 else return ((e+1) << 3) | (cast_int(x) - 8);
43}
44
45
46/* converts back */
47int luaO_fb2int (int x) {
48 int e = (x >> 3) & 31;
49 if (e == 0) return x;
50 else return ((x & 7)+8) << (e - 1);
51}
52
53
54int luaO_log2 (unsigned int x) {
55 static const lu_byte log_2[256] = {
56 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
57 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
58 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
59 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
60 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
61 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
62 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
63 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
64 };
65 int l = -1;
66 while (x >= 256) { l += 8; x >>= 8; }
67 return l + log_2[x];
68
69}
70
71
72int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
73 if (ttype(t1) != ttype(t2)) return 0;
74 else switch (ttype(t1)) {
75 case LUA_TNIL:
76 return 1;
77 case LUA_TNUMBER:
78 return luai_numeq(nvalue(t1), nvalue(t2));
79 case LUA_TBOOLEAN:
80 return bvalue(t1) == bvalue(t2); /* boolean true must be 1 !! */
81 case LUA_TLIGHTUSERDATA:
82 return pvalue(t1) == pvalue(t2);
83 default:
84 lua_assert(iscollectable(t1));
85 return gcvalue(t1) == gcvalue(t2);
86 }
87}
88
89
90int luaO_str2d (const char *s, lua_Number *result) {
91 char *endptr;
92 *result = lua_str2number(s, &endptr);
93 if (endptr == s) return 0; /* conversion failed */
94 if (*endptr == 'x' || *endptr == 'X') /* maybe an hexadecimal constant? */
95 *result = cast_num(strtoul(s, &endptr, 16));
96 if (*endptr == '\0') return 1; /* most common case */
97 while (isspace(cast(unsigned char, *endptr))) endptr++;
98 if (*endptr != '\0') return 0; /* invalid trailing characters? */
99 return 1;
100}
101
102
103
104static void pushstr (lua_State *L, const char *str) {
105 setsvalue2s(L, L->top, luaS_new(L, str));
106 incr_top(L);
107}
108
109
110/* this function handles only `%d', `%c', %f, %p, and `%s' formats */
111const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
112 int n = 1;
113 pushstr(L, "");
114 for (;;) {
115 const char *e = strchr(fmt, '%');
116 if (e == NULL) break;
117 setsvalue2s(L, L->top, luaS_newlstr(L, fmt, e-fmt));
118 incr_top(L);
119 switch (*(e+1)) {
120 case 's': {
121 const char *s = va_arg(argp, char *);
122 if (s == NULL) s = "(null)";
123 pushstr(L, s);
124 break;
125 }
126 case 'c': {
127 char buff[2];
128 buff[0] = cast(char, va_arg(argp, int));
129 buff[1] = '\0';
130 pushstr(L, buff);
131 break;
132 }
133 case 'd': {
134 setnvalue(L->top, cast_num(va_arg(argp, int)));
135 incr_top(L);
136 break;
137 }
138 case 'f': {
139 setnvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));
140 incr_top(L);
141 break;
142 }
143 case 'p': {
144 char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */
145 sprintf(buff, "%p", va_arg(argp, void *));
146 pushstr(L, buff);
147 break;
148 }
149 case '%': {
150 pushstr(L, "%");
151 break;
152 }
153 default: {
154 char buff[3];
155 buff[0] = '%';
156 buff[1] = *(e+1);
157 buff[2] = '\0';
158 pushstr(L, buff);
159 break;
160 }
161 }
162 n += 2;
163 fmt = e+2;
164 }
165 pushstr(L, fmt);
166 luaV_concat(L, n+1, cast_int(L->top - L->base) - 1);
167 L->top -= n;
168 return svalue(L->top - 1);
169}
170
171
172const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
173 const char *msg;
174 va_list argp;
175 va_start(argp, fmt);
176 msg = luaO_pushvfstring(L, fmt, argp);
177 va_end(argp);
178 return msg;
179}
180
181
182void luaO_chunkid (char *out, const char *source, size_t bufflen) {
183 if (*source == '=') {
184 strncpy(out, source+1, bufflen); /* remove first char */
185 out[bufflen-1] = '\0'; /* ensures null termination */
186 }
187 else { /* out = "source", or "...source" */
188 if (*source == '@') {
189 size_t l;
190 source++; /* skip the `@' */
191 bufflen -= sizeof(" '...' ");
192 l = strlen(source);
193 strcpy(out, "");
194 if (l > bufflen) {
195 source += (l-bufflen); /* get last part of file name */
196 strcat(out, "...");
197 }
198 strcat(out, source);
199 }
200 else { /* out = [string "string"] */
201 size_t len = strcspn(source, "\n\r"); /* stop at first newline */
202 bufflen -= sizeof(" [string \"...\"] ");
203 if (len > bufflen) len = bufflen;
204 strcpy(out, "[string \"");
205 if (source[len] != '\0') { /* must truncate? */
206 strncat(out, source, len);
207 strcat(out, "...");
208 }
209 else
210 strcat(out, source);
211 strcat(out, "\"]");
212 }
213 }
214}
diff --git a/libraries/LuaJIT-1.1.7/src/lobject.h b/libraries/LuaJIT-1.1.7/src/lobject.h
new file mode 100644
index 0000000..df9c528
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lobject.h
@@ -0,0 +1,386 @@
1/*
2** $Id: lobject.h,v 2.20.1.2 2008/08/06 13:29:48 roberto Exp $
3** Type definitions for Lua objects
4** See Copyright Notice in lua.h
5*/
6
7
8#ifndef lobject_h
9#define lobject_h
10
11
12#include <stdarg.h>
13
14
15#include "llimits.h"
16#include "lua.h"
17
18
19/* tags for values visible from Lua */
20#define LAST_TAG LUA_TTHREAD
21
22#define NUM_TAGS (LAST_TAG+1)
23
24
25/*
26** Extra tags for non-values
27*/
28#define LUA_TPROTO (LAST_TAG+1)
29#define LUA_TUPVAL (LAST_TAG+2)
30#define LUA_TDEADKEY (LAST_TAG+3)
31
32
33/*
34** Union of all collectable objects
35*/
36typedef union GCObject GCObject;
37
38
39/*
40** Common Header for all collectable objects (in macro form, to be
41** included in other objects)
42*/
43#define CommonHeader GCObject *next; lu_byte tt; lu_byte marked
44
45
46/*
47** Common header in struct form
48*/
49typedef struct GCheader {
50 CommonHeader;
51} GCheader;
52
53
54
55
56/*
57** Union of all Lua values
58*/
59typedef union {
60 GCObject *gc;
61 void *p;
62 lua_Number n;
63 ptrdiff_t na[sizeof(lua_Number)/sizeof(ptrdiff_t)]; /* LuaJIT kludge */
64 int b;
65} Value;
66
67
68/*
69** Tagged Values
70*/
71
72#define TValuefields Value value; int tt
73
74typedef struct lua_TValue {
75 TValuefields;
76} LUA_TVALUE_ALIGN TValue;
77
78
79/* Macros to test type */
80#define ttisnil(o) (ttype(o) == LUA_TNIL)
81#define ttisnumber(o) (ttype(o) == LUA_TNUMBER)
82#define ttisstring(o) (ttype(o) == LUA_TSTRING)
83#define ttistable(o) (ttype(o) == LUA_TTABLE)
84#define ttisfunction(o) (ttype(o) == LUA_TFUNCTION)
85#define ttisboolean(o) (ttype(o) == LUA_TBOOLEAN)
86#define ttisuserdata(o) (ttype(o) == LUA_TUSERDATA)
87#define ttisthread(o) (ttype(o) == LUA_TTHREAD)
88#define ttislightuserdata(o) (ttype(o) == LUA_TLIGHTUSERDATA)
89
90/* Macros to access values */
91#define ttype(o) ((o)->tt)
92#define gcvalue(o) check_exp(iscollectable(o), (o)->value.gc)
93#define pvalue(o) check_exp(ttislightuserdata(o), (o)->value.p)
94#define nvalue(o) check_exp(ttisnumber(o), (o)->value.n)
95#define rawtsvalue(o) check_exp(ttisstring(o), &(o)->value.gc->ts)
96#define tsvalue(o) (&rawtsvalue(o)->tsv)
97#define rawuvalue(o) check_exp(ttisuserdata(o), &(o)->value.gc->u)
98#define uvalue(o) (&rawuvalue(o)->uv)
99#define clvalue(o) check_exp(ttisfunction(o), &(o)->value.gc->cl)
100#define hvalue(o) check_exp(ttistable(o), &(o)->value.gc->h)
101#define bvalue(o) check_exp(ttisboolean(o), (o)->value.b)
102#define thvalue(o) check_exp(ttisthread(o), &(o)->value.gc->th)
103
104#define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
105
106/*
107** for internal debug only
108*/
109#define checkconsistency(obj) \
110 lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc->gch.tt))
111
112#define checkliveness(g,obj) \
113 lua_assert(!iscollectable(obj) || \
114 ((ttype(obj) == (obj)->value.gc->gch.tt) && !isdead(g, (obj)->value.gc)))
115
116
117/* Macros to set values */
118#define setnilvalue(obj) ((obj)->tt=LUA_TNIL)
119
120#define setnvalue(obj,x) \
121 { TValue *i_o=(obj); i_o->value.n=(x); i_o->tt=LUA_TNUMBER; }
122
123#define setpvalue(obj,x) \
124 { TValue *i_o=(obj); i_o->value.p=(x); i_o->tt=LUA_TLIGHTUSERDATA; }
125
126#define setbvalue(obj,x) \
127 { TValue *i_o=(obj); i_o->value.b=(x); i_o->tt=LUA_TBOOLEAN; }
128
129#define setsvalue(L,obj,x) \
130 { TValue *i_o=(obj); \
131 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TSTRING; \
132 checkliveness(G(L),i_o); }
133
134#define setuvalue(L,obj,x) \
135 { TValue *i_o=(obj); \
136 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TUSERDATA; \
137 checkliveness(G(L),i_o); }
138
139#define setthvalue(L,obj,x) \
140 { TValue *i_o=(obj); \
141 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTHREAD; \
142 checkliveness(G(L),i_o); }
143
144#define setclvalue(L,obj,x) \
145 { TValue *i_o=(obj); \
146 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TFUNCTION; \
147 checkliveness(G(L),i_o); }
148
149#define sethvalue(L,obj,x) \
150 { TValue *i_o=(obj); \
151 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTABLE; \
152 checkliveness(G(L),i_o); }
153
154#define setptvalue(L,obj,x) \
155 { TValue *i_o=(obj); \
156 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TPROTO; \
157 checkliveness(G(L),i_o); }
158
159
160
161
162#define setobj(L,obj1,obj2) \
163 { const TValue *o2=(obj2); TValue *o1=(obj1); \
164 o1->value = o2->value; o1->tt=o2->tt; \
165 checkliveness(G(L),o1); }
166
167
168/*
169** different types of sets, according to destination
170*/
171
172/* from stack to (same) stack */
173#define setobjs2s setobj
174/* to stack (not from same stack) */
175#define setobj2s setobj
176#define setsvalue2s setsvalue
177#define sethvalue2s sethvalue
178#define setptvalue2s setptvalue
179/* from table to same table */
180#define setobjt2t setobj
181/* to table */
182#define setobj2t setobj
183/* to new object */
184#define setobj2n setobj
185#define setsvalue2n setsvalue
186
187#define setttype(obj, tt) (ttype(obj) = (tt))
188
189
190#define iscollectable(o) (ttype(o) >= LUA_TSTRING)
191
192
193
194typedef TValue *StkId; /* index to stack elements */
195
196
197/*
198** String headers for string table
199*/
200typedef union TString {
201 L_Umaxalign dummy; /* ensures maximum alignment for strings */
202 struct {
203 CommonHeader;
204 lu_byte reserved;
205 unsigned int hash;
206 size_t len;
207 } tsv;
208} TString;
209
210
211#define getstr(ts) cast(const char *, (ts) + 1)
212#define svalue(o) getstr(rawtsvalue(o))
213
214
215
216typedef union Udata {
217 L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */
218 struct {
219 CommonHeader;
220 struct Table *metatable;
221 struct Table *env;
222 size_t len;
223 } uv;
224} Udata;
225
226
227
228
229/*
230** Function Prototypes
231*/
232typedef struct Proto {
233 CommonHeader;
234 TValue *k; /* constants used by the function */
235 Instruction *code;
236 struct Proto **p; /* functions defined inside the function */
237 int *lineinfo; /* map from opcodes to source lines */
238 struct LocVar *locvars; /* information about local variables */
239 TString **upvalues; /* upvalue names */
240 TString *source;
241 int sizeupvalues;
242 int sizek; /* size of `k' */
243 int sizecode;
244 int sizelineinfo;
245 int sizep; /* size of `p' */
246 int sizelocvars;
247 int linedefined;
248 int lastlinedefined;
249 GCObject *gclist;
250 lu_byte nups; /* number of upvalues */
251 lu_byte numparams;
252 lu_byte is_vararg;
253 lu_byte maxstacksize;
254 /* LuaJIT extensions */
255 void *jit_mcode; /* compiled machine code base address */
256 size_t jit_szmcode; /* size of compiled mcode */
257 int jit_status; /* JIT engine status code */
258} Proto;
259
260
261/* masks for new-style vararg */
262#define VARARG_HASARG 1
263#define VARARG_ISVARARG 2
264#define VARARG_NEEDSARG 4
265
266
267typedef struct LocVar {
268 TString *varname;
269 int startpc; /* first point where variable is active */
270 int endpc; /* first point where variable is dead */
271} LocVar;
272
273
274
275/*
276** Upvalues
277*/
278
279typedef struct UpVal {
280 CommonHeader;
281 TValue *v; /* points to stack or to its own value */
282 union {
283 TValue value; /* the value (when closed) */
284 struct { /* double linked list (when open) */
285 struct UpVal *prev;
286 struct UpVal *next;
287 } l;
288 } u;
289} UpVal;
290
291
292/*
293** Closures
294*/
295
296#define ClosureHeader \
297 CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \
298 struct Table *env; lua_CFunction jit_gate
299
300typedef struct CClosure {
301 ClosureHeader;
302 lua_CFunction f;
303 TValue upvalue[1];
304} CClosure;
305
306
307typedef struct LClosure {
308 ClosureHeader;
309 struct Proto *p;
310 UpVal *upvals[1];
311} LClosure;
312
313
314typedef union Closure {
315 CClosure c;
316 LClosure l;
317} Closure;
318
319
320#define iscfunction(o) (ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC)
321#define isLfunction(o) (ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC)
322
323
324/*
325** Tables
326*/
327
328typedef union TKey {
329 struct {
330 TValuefields;
331 struct Node *next; /* for chaining */
332 } nk;
333 TValue tvk;
334} TKey;
335
336
337typedef struct Node {
338 TValue i_val;
339 TKey i_key;
340} Node;
341
342
343typedef struct Table {
344 CommonHeader;
345 lu_byte flags; /* 1<<p means tagmethod(p) is not present */
346 lu_byte lsizenode; /* log2 of size of `node' array */
347 struct Table *metatable;
348 TValue *array; /* array part */
349 Node *node;
350 Node *lastfree; /* any free position is before this position */
351 GCObject *gclist;
352 int sizearray; /* size of `array' array */
353} Table;
354
355
356
357/*
358** `module' operation for hashing (size is always a power of 2)
359*/
360#define lmod(s,size) \
361 (check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1)))))
362
363
364#define twoto(x) (1<<(x))
365#define sizenode(t) (twoto((t)->lsizenode))
366
367
368#define luaO_nilobject (&luaO_nilobject_)
369
370LUAI_DATA const TValue luaO_nilobject_;
371
372#define ceillog2(x) (luaO_log2((x)-1) + 1)
373
374LUAI_FUNC int luaO_log2 (unsigned int x);
375LUAI_FUNC int luaO_int2fb (unsigned int x);
376LUAI_FUNC int luaO_fb2int (int x);
377LUAI_FUNC int luaO_rawequalObj (const TValue *t1, const TValue *t2);
378LUAI_FUNC int luaO_str2d (const char *s, lua_Number *result);
379LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
380 va_list argp);
381LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
382LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);
383
384
385#endif
386
diff --git a/libraries/LuaJIT-1.1.7/src/lopcodes.c b/libraries/LuaJIT-1.1.7/src/lopcodes.c
new file mode 100644
index 0000000..4cc7452
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lopcodes.c
@@ -0,0 +1,102 @@
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
16const 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
61const 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
diff --git a/libraries/LuaJIT-1.1.7/src/lopcodes.h b/libraries/LuaJIT-1.1.7/src/lopcodes.h
new file mode 100644
index 0000000..41224d6
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lopcodes.h
@@ -0,0 +1,268 @@
1/*
2** $Id: lopcodes.h,v 1.125.1.1 2007/12/27 13:02:25 roberto Exp $
3** Opcodes for Lua virtual machine
4** See Copyright Notice in lua.h
5*/
6
7#ifndef lopcodes_h
8#define lopcodes_h
9
10#include "llimits.h"
11
12
13/*===========================================================================
14 We assume that instructions are unsigned numbers.
15 All instructions have an opcode in the first 6 bits.
16 Instructions can have the following fields:
17 `A' : 8 bits
18 `B' : 9 bits
19 `C' : 9 bits
20 `Bx' : 18 bits (`B' and `C' together)
21 `sBx' : signed Bx
22
23 A signed argument is represented in excess K; that is, the number
24 value is the unsigned value minus K. K is exactly the maximum value
25 for that argument (so that -max is represented by 0, and +max is
26 represented by 2*max), which is half the maximum for the corresponding
27 unsigned argument.
28===========================================================================*/
29
30
31enum OpMode {iABC, iABx, iAsBx}; /* basic instruction format */
32
33
34/*
35** size and position of opcode arguments.
36*/
37#define SIZE_C 9
38#define SIZE_B 9
39#define SIZE_Bx (SIZE_C + SIZE_B)
40#define SIZE_A 8
41
42#define SIZE_OP 6
43
44#define POS_OP 0
45#define POS_A (POS_OP + SIZE_OP)
46#define POS_C (POS_A + SIZE_A)
47#define POS_B (POS_C + SIZE_C)
48#define POS_Bx POS_C
49
50
51/*
52** limits for opcode arguments.
53** we use (signed) int to manipulate most arguments,
54** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
55*/
56#if SIZE_Bx < LUAI_BITSINT-1
57#define MAXARG_Bx ((1<<SIZE_Bx)-1)
58#define MAXARG_sBx (MAXARG_Bx>>1) /* `sBx' is signed */
59#else
60#define MAXARG_Bx MAX_INT
61#define MAXARG_sBx MAX_INT
62#endif
63
64
65#define MAXARG_A ((1<<SIZE_A)-1)
66#define MAXARG_B ((1<<SIZE_B)-1)
67#define MAXARG_C ((1<<SIZE_C)-1)
68
69
70/* creates a mask with `n' 1 bits at position `p' */
71#define MASK1(n,p) ((~((~(Instruction)0)<<n))<<p)
72
73/* creates a mask with `n' 0 bits at position `p' */
74#define MASK0(n,p) (~MASK1(n,p))
75
76/*
77** the following macros help to manipulate instructions
78*/
79
80#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
81#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
82 ((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
83
84#define GETARG_A(i) (cast(int, ((i)>>POS_A) & MASK1(SIZE_A,0)))
85#define SETARG_A(i,u) ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
86 ((cast(Instruction, u)<<POS_A)&MASK1(SIZE_A,POS_A))))
87
88#define GETARG_B(i) (cast(int, ((i)>>POS_B) & MASK1(SIZE_B,0)))
89#define SETARG_B(i,b) ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
90 ((cast(Instruction, b)<<POS_B)&MASK1(SIZE_B,POS_B))))
91
92#define GETARG_C(i) (cast(int, ((i)>>POS_C) & MASK1(SIZE_C,0)))
93#define SETARG_C(i,b) ((i) = (((i)&MASK0(SIZE_C,POS_C)) | \
94 ((cast(Instruction, b)<<POS_C)&MASK1(SIZE_C,POS_C))))
95
96#define GETARG_Bx(i) (cast(int, ((i)>>POS_Bx) & MASK1(SIZE_Bx,0)))
97#define SETARG_Bx(i,b) ((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \
98 ((cast(Instruction, b)<<POS_Bx)&MASK1(SIZE_Bx,POS_Bx))))
99
100#define GETARG_sBx(i) (GETARG_Bx(i)-MAXARG_sBx)
101#define SETARG_sBx(i,b) SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
102
103
104#define CREATE_ABC(o,a,b,c) ((cast(Instruction, o)<<POS_OP) \
105 | (cast(Instruction, a)<<POS_A) \
106 | (cast(Instruction, b)<<POS_B) \
107 | (cast(Instruction, c)<<POS_C))
108
109#define CREATE_ABx(o,a,bc) ((cast(Instruction, o)<<POS_OP) \
110 | (cast(Instruction, a)<<POS_A) \
111 | (cast(Instruction, bc)<<POS_Bx))
112
113
114/*
115** Macros to operate RK indices
116*/
117
118/* this bit 1 means constant (0 means register) */
119#define BITRK (1 << (SIZE_B - 1))
120
121/* test whether value is a constant */
122#define ISK(x) ((x) & BITRK)
123
124/* gets the index of the constant */
125#define INDEXK(r) ((int)(r) & ~BITRK)
126
127#define MAXINDEXRK (BITRK - 1)
128
129/* code a constant index as a RK value */
130#define RKASK(x) ((x) | BITRK)
131
132
133/*
134** invalid register that fits in 8 bits
135*/
136#define NO_REG MAXARG_A
137
138
139/*
140** R(x) - register
141** Kst(x) - constant (in constant table)
142** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
143*/
144
145
146/*
147** grep "ORDER OP" if you change these enums
148*/
149
150typedef enum {
151/*----------------------------------------------------------------------
152name args description
153------------------------------------------------------------------------*/
154OP_MOVE,/* A B R(A) := R(B) */
155OP_LOADK,/* A Bx R(A) := Kst(Bx) */
156OP_LOADBOOL,/* A B C R(A) := (Bool)B; if (C) pc++ */
157OP_LOADNIL,/* A B R(A) := ... := R(B) := nil */
158OP_GETUPVAL,/* A B R(A) := UpValue[B] */
159
160OP_GETGLOBAL,/* A Bx R(A) := Gbl[Kst(Bx)] */
161OP_GETTABLE,/* A B C R(A) := R(B)[RK(C)] */
162
163OP_SETGLOBAL,/* A Bx Gbl[Kst(Bx)] := R(A) */
164OP_SETUPVAL,/* A B UpValue[B] := R(A) */
165OP_SETTABLE,/* A B C R(A)[RK(B)] := RK(C) */
166
167OP_NEWTABLE,/* A B C R(A) := {} (size = B,C) */
168
169OP_SELF,/* A B C R(A+1) := R(B); R(A) := R(B)[RK(C)] */
170
171OP_ADD,/* A B C R(A) := RK(B) + RK(C) */
172OP_SUB,/* A B C R(A) := RK(B) - RK(C) */
173OP_MUL,/* A B C R(A) := RK(B) * RK(C) */
174OP_DIV,/* A B C R(A) := RK(B) / RK(C) */
175OP_MOD,/* A B C R(A) := RK(B) % RK(C) */
176OP_POW,/* A B C R(A) := RK(B) ^ RK(C) */
177OP_UNM,/* A B R(A) := -R(B) */
178OP_NOT,/* A B R(A) := not R(B) */
179OP_LEN,/* A B R(A) := length of R(B) */
180
181OP_CONCAT,/* A B C R(A) := R(B).. ... ..R(C) */
182
183OP_JMP,/* sBx pc+=sBx */
184
185OP_EQ,/* A B C if ((RK(B) == RK(C)) ~= A) then pc++ */
186OP_LT,/* A B C if ((RK(B) < RK(C)) ~= A) then pc++ */
187OP_LE,/* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */
188
189OP_TEST,/* A C if not (R(A) <=> C) then pc++ */
190OP_TESTSET,/* A B C if (R(B) <=> C) then R(A) := R(B) else pc++ */
191
192OP_CALL,/* A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
193OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */
194OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */
195
196OP_FORLOOP,/* A sBx R(A)+=R(A+2);
197 if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
198OP_FORPREP,/* A sBx R(A)-=R(A+2); pc+=sBx */
199
200OP_TFORLOOP,/* A C R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));
201 if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++ */
202OP_SETLIST,/* A B C R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B */
203
204OP_CLOSE,/* A close all variables in the stack up to (>=) R(A)*/
205OP_CLOSURE,/* A Bx R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n)) */
206
207OP_VARARG/* A B R(A), R(A+1), ..., R(A+B-1) = vararg */
208} OpCode;
209
210
211#define NUM_OPCODES (cast(int, OP_VARARG) + 1)
212
213
214
215/*===========================================================================
216 Notes:
217 (*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
218 and can be 0: OP_CALL then sets `top' to last_result+1, so
219 next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'.
220
221 (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
222 set top (like in OP_CALL with C == 0).
223
224 (*) In OP_RETURN, if (B == 0) then return up to `top'
225
226 (*) In OP_SETLIST, if (B == 0) then B = `top';
227 if (C == 0) then next `instruction' is real C
228
229 (*) For comparisons, A specifies what condition the test should accept
230 (true or false).
231
232 (*) All `skips' (pc++) assume that next instruction is a jump
233===========================================================================*/
234
235
236/*
237** masks for instruction properties. The format is:
238** bits 0-1: op mode
239** bits 2-3: C arg mode
240** bits 4-5: B arg mode
241** bit 6: instruction set register A
242** bit 7: operator is a test
243*/
244
245enum OpArgMask {
246 OpArgN, /* argument is not used */
247 OpArgU, /* argument is used */
248 OpArgR, /* argument is a register or a jump offset */
249 OpArgK /* argument is a constant or register/constant */
250};
251
252LUAI_DATA const lu_byte luaP_opmodes[NUM_OPCODES];
253
254#define getOpMode(m) (cast(enum OpMode, luaP_opmodes[m] & 3))
255#define getBMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
256#define getCMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
257#define testAMode(m) (luaP_opmodes[m] & (1 << 6))
258#define testTMode(m) (luaP_opmodes[m] & (1 << 7))
259
260
261LUAI_DATA const char *const luaP_opnames[NUM_OPCODES+1]; /* opcode names */
262
263
264/* number of list items to accumulate before a SETLIST instruction */
265#define LFIELDS_PER_FLUSH 50
266
267
268#endif
diff --git a/libraries/LuaJIT-1.1.7/src/loslib.c b/libraries/LuaJIT-1.1.7/src/loslib.c
new file mode 100644
index 0000000..01a02a2
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/loslib.c
@@ -0,0 +1,244 @@
1/*
2** $Id: loslib.c,v 1.19.1.3 2008/01/18 16:38:18 roberto Exp $
3** Standard Operating System library
4** See Copyright Notice in lua.h
5*/
6
7
8#include <errno.h>
9#include <locale.h>
10#include <stdlib.h>
11#include <string.h>
12#include <time.h>
13
14#define loslib_c
15#define LUA_LIB
16
17#include "lua.h"
18
19#include "lauxlib.h"
20#include "lualib.h"
21
22
23static int os_pushresult (lua_State *L, int i, const char *filename) {
24 int en = errno; /* calls to Lua API may change this value */
25 if (i) {
26 lua_pushboolean(L, 1);
27 return 1;
28 }
29 else {
30 lua_pushnil(L);
31 lua_pushfstring(L, "%s: %s", filename, strerror(en));
32 lua_pushinteger(L, en);
33 return 3;
34 }
35}
36
37
38static int os_execute (lua_State *L) {
39 lua_pushinteger(L, system(luaL_optstring(L, 1, NULL)));
40 return 1;
41}
42
43
44static int os_remove (lua_State *L) {
45 const char *filename = luaL_checkstring(L, 1);
46 return os_pushresult(L, remove(filename) == 0, filename);
47}
48
49
50static int os_rename (lua_State *L) {
51 const char *fromname = luaL_checkstring(L, 1);
52 const char *toname = luaL_checkstring(L, 2);
53 return os_pushresult(L, rename(fromname, toname) == 0, fromname);
54}
55
56
57static int os_tmpname (lua_State *L) {
58 char buff[LUA_TMPNAMBUFSIZE];
59 int err;
60 lua_tmpnam(buff, err);
61 if (err)
62 return luaL_error(L, "unable to generate a unique filename");
63 lua_pushstring(L, buff);
64 return 1;
65}
66
67
68static int os_getenv (lua_State *L) {
69 lua_pushstring(L, getenv(luaL_checkstring(L, 1))); /* if NULL push nil */
70 return 1;
71}
72
73
74static int os_clock (lua_State *L) {
75 lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);
76 return 1;
77}
78
79
80/*
81** {======================================================
82** Time/Date operations
83** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,
84** wday=%w+1, yday=%j, isdst=? }
85** =======================================================
86*/
87
88static void setfield (lua_State *L, const char *key, int value) {
89 lua_pushinteger(L, value);
90 lua_setfield(L, -2, key);
91}
92
93static void setboolfield (lua_State *L, const char *key, int value) {
94 if (value < 0) /* undefined? */
95 return; /* does not set field */
96 lua_pushboolean(L, value);
97 lua_setfield(L, -2, key);
98}
99
100static int getboolfield (lua_State *L, const char *key) {
101 int res;
102 lua_getfield(L, -1, key);
103 res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);
104 lua_pop(L, 1);
105 return res;
106}
107
108
109static int getfield (lua_State *L, const char *key, int d) {
110 int res;
111 lua_getfield(L, -1, key);
112 if (lua_isnumber(L, -1))
113 res = (int)lua_tointeger(L, -1);
114 else {
115 if (d < 0)
116 return luaL_error(L, "field " LUA_QS " missing in date table", key);
117 res = d;
118 }
119 lua_pop(L, 1);
120 return res;
121}
122
123
124static int os_date (lua_State *L) {
125 const char *s = luaL_optstring(L, 1, "%c");
126 time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL));
127 struct tm *stm;
128 if (*s == '!') { /* UTC? */
129 stm = gmtime(&t);
130 s++; /* skip `!' */
131 }
132 else
133 stm = localtime(&t);
134 if (stm == NULL) /* invalid date? */
135 lua_pushnil(L);
136 else if (strcmp(s, "*t") == 0) {
137 lua_createtable(L, 0, 9); /* 9 = number of fields */
138 setfield(L, "sec", stm->tm_sec);
139 setfield(L, "min", stm->tm_min);
140 setfield(L, "hour", stm->tm_hour);
141 setfield(L, "day", stm->tm_mday);
142 setfield(L, "month", stm->tm_mon+1);
143 setfield(L, "year", stm->tm_year+1900);
144 setfield(L, "wday", stm->tm_wday+1);
145 setfield(L, "yday", stm->tm_yday+1);
146 setboolfield(L, "isdst", stm->tm_isdst);
147 }
148 else {
149 char cc[3];
150 luaL_Buffer b;
151 cc[0] = '%'; cc[2] = '\0';
152 luaL_buffinit(L, &b);
153 for (; *s; s++) {
154 if (*s != '%' || *(s + 1) == '\0') /* no conversion specifier? */
155 luaL_addchar(&b, *s);
156 else {
157 size_t reslen;
158 char buff[200]; /* should be big enough for any conversion result */
159 cc[1] = *(++s);
160 reslen = strftime(buff, sizeof(buff), cc, stm);
161 luaL_addlstring(&b, buff, reslen);
162 }
163 }
164 luaL_pushresult(&b);
165 }
166 return 1;
167}
168
169
170static int os_time (lua_State *L) {
171 time_t t;
172 if (lua_isnoneornil(L, 1)) /* called without args? */
173 t = time(NULL); /* get current time */
174 else {
175 struct tm ts;
176 luaL_checktype(L, 1, LUA_TTABLE);
177 lua_settop(L, 1); /* make sure table is at the top */
178 ts.tm_sec = getfield(L, "sec", 0);
179 ts.tm_min = getfield(L, "min", 0);
180 ts.tm_hour = getfield(L, "hour", 12);
181 ts.tm_mday = getfield(L, "day", -1);
182 ts.tm_mon = getfield(L, "month", -1) - 1;
183 ts.tm_year = getfield(L, "year", -1) - 1900;
184 ts.tm_isdst = getboolfield(L, "isdst");
185 t = mktime(&ts);
186 }
187 if (t == (time_t)(-1))
188 lua_pushnil(L);
189 else
190 lua_pushnumber(L, (lua_Number)t);
191 return 1;
192}
193
194
195static int os_difftime (lua_State *L) {
196 lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)),
197 (time_t)(luaL_optnumber(L, 2, 0))));
198 return 1;
199}
200
201/* }====================================================== */
202
203
204static int os_setlocale (lua_State *L) {
205 static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
206 LC_NUMERIC, LC_TIME};
207 static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
208 "numeric", "time", NULL};
209 const char *l = luaL_optstring(L, 1, NULL);
210 int op = luaL_checkoption(L, 2, "all", catnames);
211 lua_pushstring(L, setlocale(cat[op], l));
212 return 1;
213}
214
215
216static int os_exit (lua_State *L) {
217 exit(luaL_optint(L, 1, EXIT_SUCCESS));
218 return 0; /* to avoid warnings */
219}
220
221static const luaL_Reg syslib[] = {
222 {"clock", os_clock},
223 {"date", os_date},
224 {"difftime", os_difftime},
225 {"execute", os_execute},
226 {"exit", os_exit},
227 {"getenv", os_getenv},
228 {"remove", os_remove},
229 {"rename", os_rename},
230 {"setlocale", os_setlocale},
231 {"time", os_time},
232 {"tmpname", os_tmpname},
233 {NULL, NULL}
234};
235
236/* }====================================================== */
237
238
239
240LUALIB_API int luaopen_os (lua_State *L) {
241 luaL_register(L, LUA_OSLIBNAME, syslib);
242 return 1;
243}
244
diff --git a/libraries/LuaJIT-1.1.7/src/lparser.c b/libraries/LuaJIT-1.1.7/src/lparser.c
new file mode 100644
index 0000000..1e2a9a8
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lparser.c
@@ -0,0 +1,1339 @@
1/*
2** $Id: lparser.c,v 2.42.1.3 2007/12/28 15:32:23 roberto Exp $
3** Lua Parser
4** See Copyright Notice in lua.h
5*/
6
7
8#include <string.h>
9
10#define lparser_c
11#define LUA_CORE
12
13#include "lua.h"
14
15#include "lcode.h"
16#include "ldebug.h"
17#include "ldo.h"
18#include "lfunc.h"
19#include "llex.h"
20#include "lmem.h"
21#include "lobject.h"
22#include "lopcodes.h"
23#include "lparser.h"
24#include "lstate.h"
25#include "lstring.h"
26#include "ltable.h"
27
28
29
30#define hasmultret(k) ((k) == VCALL || (k) == VVARARG)
31
32#define getlocvar(fs, i) ((fs)->f->locvars[(fs)->actvar[i]])
33
34#define luaY_checklimit(fs,v,l,m) if ((v)>(l)) errorlimit(fs,l,m)
35
36
37/*
38** nodes for block list (list of active blocks)
39*/
40typedef struct BlockCnt {
41 struct BlockCnt *previous; /* chain */
42 int breaklist; /* list of jumps out of this loop */
43 lu_byte nactvar; /* # active locals outside the breakable structure */
44 lu_byte upval; /* true if some variable in the block is an upvalue */
45 lu_byte isbreakable; /* true if `block' is a loop */
46} BlockCnt;
47
48
49
50/*
51** prototypes for recursive non-terminal functions
52*/
53static void chunk (LexState *ls);
54static void expr (LexState *ls, expdesc *v);
55
56
57static void anchor_token (LexState *ls) {
58 if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {
59 TString *ts = ls->t.seminfo.ts;
60 luaX_newstring(ls, getstr(ts), ts->tsv.len);
61 }
62}
63
64
65static void error_expected (LexState *ls, int token) {
66 luaX_syntaxerror(ls,
67 luaO_pushfstring(ls->L, LUA_QS " expected", luaX_token2str(ls, token)));
68}
69
70
71static void errorlimit (FuncState *fs, int limit, const char *what) {
72 const char *msg = (fs->f->linedefined == 0) ?
73 luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :
74 luaO_pushfstring(fs->L, "function at line %d has more than %d %s",
75 fs->f->linedefined, limit, what);
76 luaX_lexerror(fs->ls, msg, 0);
77}
78
79
80static int testnext (LexState *ls, int c) {
81 if (ls->t.token == c) {
82 luaX_next(ls);
83 return 1;
84 }
85 else return 0;
86}
87
88
89static void check (LexState *ls, int c) {
90 if (ls->t.token != c)
91 error_expected(ls, c);
92}
93
94static void checknext (LexState *ls, int c) {
95 check(ls, c);
96 luaX_next(ls);
97}
98
99
100#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); }
101
102
103
104static void check_match (LexState *ls, int what, int who, int where) {
105 if (!testnext(ls, what)) {
106 if (where == ls->linenumber)
107 error_expected(ls, what);
108 else {
109 luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
110 LUA_QS " expected (to close " LUA_QS " at line %d)",
111 luaX_token2str(ls, what), luaX_token2str(ls, who), where));
112 }
113 }
114}
115
116
117static TString *str_checkname (LexState *ls) {
118 TString *ts;
119 check(ls, TK_NAME);
120 ts = ls->t.seminfo.ts;
121 luaX_next(ls);
122 return ts;
123}
124
125
126static void init_exp (expdesc *e, expkind k, int i) {
127 e->f = e->t = NO_JUMP;
128 e->k = k;
129 e->u.s.info = i;
130}
131
132
133static void codestring (LexState *ls, expdesc *e, TString *s) {
134 init_exp(e, VK, luaK_stringK(ls->fs, s));
135}
136
137
138static void checkname(LexState *ls, expdesc *e) {
139 codestring(ls, e, str_checkname(ls));
140}
141
142
143static int registerlocalvar (LexState *ls, TString *varname) {
144 FuncState *fs = ls->fs;
145 Proto *f = fs->f;
146 int oldsize = f->sizelocvars;
147 luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
148 LocVar, SHRT_MAX, "too many local variables");
149 while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL;
150 f->locvars[fs->nlocvars].varname = varname;
151 luaC_objbarrier(ls->L, f, varname);
152 return fs->nlocvars++;
153}
154
155
156#define new_localvarliteral(ls,v,n) \
157 new_localvar(ls, luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char))-1), n)
158
159
160static void new_localvar (LexState *ls, TString *name, int n) {
161 FuncState *fs = ls->fs;
162 luaY_checklimit(fs, fs->nactvar+n+1, LUAI_MAXVARS, "local variables");
163 fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name));
164}
165
166
167static void adjustlocalvars (LexState *ls, int nvars) {
168 FuncState *fs = ls->fs;
169 fs->nactvar = cast_byte(fs->nactvar + nvars);
170 for (; nvars; nvars--) {
171 getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
172 }
173}
174
175
176static void removevars (LexState *ls, int tolevel) {
177 FuncState *fs = ls->fs;
178 while (fs->nactvar > tolevel)
179 getlocvar(fs, --fs->nactvar).endpc = fs->pc;
180}
181
182
183static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {
184 int i;
185 Proto *f = fs->f;
186 int oldsize = f->sizeupvalues;
187 for (i=0; i<f->nups; i++) {
188 if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) {
189 lua_assert(f->upvalues[i] == name);
190 return i;
191 }
192 }
193 /* new one */
194 luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues");
195 luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,
196 TString *, MAX_INT, "");
197 while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;
198 f->upvalues[f->nups] = name;
199 luaC_objbarrier(fs->L, f, name);
200 lua_assert(v->k == VLOCAL || v->k == VUPVAL);
201 fs->upvalues[f->nups].k = cast_byte(v->k);
202 fs->upvalues[f->nups].info = cast_byte(v->u.s.info);
203 return f->nups++;
204}
205
206
207static int searchvar (FuncState *fs, TString *n) {
208 int i;
209 for (i=fs->nactvar-1; i >= 0; i--) {
210 if (n == getlocvar(fs, i).varname)
211 return i;
212 }
213 return -1; /* not found */
214}
215
216
217static void markupval (FuncState *fs, int level) {
218 BlockCnt *bl = fs->bl;
219 while (bl && bl->nactvar > level) bl = bl->previous;
220 if (bl) bl->upval = 1;
221}
222
223
224static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
225 if (fs == NULL) { /* no more levels? */
226 init_exp(var, VGLOBAL, NO_REG); /* default is global variable */
227 return VGLOBAL;
228 }
229 else {
230 int v = searchvar(fs, n); /* look up at current level */
231 if (v >= 0) {
232 init_exp(var, VLOCAL, v);
233 if (!base)
234 markupval(fs, v); /* local will be used as an upval */
235 return VLOCAL;
236 }
237 else { /* not found at current level; try upper one */
238 if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)
239 return VGLOBAL;
240 var->u.s.info = indexupvalue(fs, n, var); /* else was LOCAL or UPVAL */
241 var->k = VUPVAL; /* upvalue in this level */
242 return VUPVAL;
243 }
244 }
245}
246
247
248static void singlevar (LexState *ls, expdesc *var) {
249 TString *varname = str_checkname(ls);
250 FuncState *fs = ls->fs;
251 if (singlevaraux(fs, varname, var, 1) == VGLOBAL)
252 var->u.s.info = luaK_stringK(fs, varname); /* info points to global name */
253}
254
255
256static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
257 FuncState *fs = ls->fs;
258 int extra = nvars - nexps;
259 if (hasmultret(e->k)) {
260 extra++; /* includes call itself */
261 if (extra < 0) extra = 0;
262 luaK_setreturns(fs, e, extra); /* last exp. provides the difference */
263 if (extra > 1) luaK_reserveregs(fs, extra-1);
264 }
265 else {
266 if (e->k != VVOID) luaK_exp2nextreg(fs, e); /* close last expression */
267 if (extra > 0) {
268 int reg = fs->freereg;
269 luaK_reserveregs(fs, extra);
270 luaK_nil(fs, reg, extra);
271 }
272 }
273}
274
275
276static void enterlevel (LexState *ls) {
277 if (++ls->L->nCcalls > LUAI_MAXCCALLS)
278 luaX_lexerror(ls, "chunk has too many syntax levels", 0);
279}
280
281
282#define leavelevel(ls) ((ls)->L->nCcalls--)
283
284
285static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) {
286 bl->breaklist = NO_JUMP;
287 bl->isbreakable = isbreakable;
288 bl->nactvar = fs->nactvar;
289 bl->upval = 0;
290 bl->previous = fs->bl;
291 fs->bl = bl;
292 lua_assert(fs->freereg == fs->nactvar);
293}
294
295
296static void leaveblock (FuncState *fs) {
297 BlockCnt *bl = fs->bl;
298 fs->bl = bl->previous;
299 removevars(fs->ls, bl->nactvar);
300 if (bl->upval)
301 luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
302 /* a block either controls scope or breaks (never both) */
303 lua_assert(!bl->isbreakable || !bl->upval);
304 lua_assert(bl->nactvar == fs->nactvar);
305 fs->freereg = fs->nactvar; /* free registers */
306 luaK_patchtohere(fs, bl->breaklist);
307}
308
309
310static void pushclosure (LexState *ls, FuncState *func, expdesc *v) {
311 FuncState *fs = ls->fs;
312 Proto *f = fs->f;
313 int oldsize = f->sizep;
314 int i;
315 luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,
316 MAXARG_Bx, "constant table overflow");
317 while (oldsize < f->sizep) f->p[oldsize++] = NULL;
318 f->p[fs->np++] = func->f;
319 luaC_objbarrier(ls->L, f, func->f);
320 init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));
321 for (i=0; i<func->f->nups; i++) {
322 OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
323 luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);
324 }
325}
326
327
328static void open_func (LexState *ls, FuncState *fs) {
329 lua_State *L = ls->L;
330 Proto *f = luaF_newproto(L);
331 fs->f = f;
332 fs->prev = ls->fs; /* linked list of funcstates */
333 fs->ls = ls;
334 fs->L = L;
335 ls->fs = fs;
336 fs->pc = 0;
337 fs->lasttarget = -1;
338 fs->jpc = NO_JUMP;
339 fs->freereg = 0;
340 fs->nk = 0;
341 fs->np = 0;
342 fs->nlocvars = 0;
343 fs->nactvar = 0;
344 fs->bl = NULL;
345 f->source = ls->source;
346 f->maxstacksize = 2; /* registers 0/1 are always valid */
347 fs->h = luaH_new(L, 0, 0);
348 /* anchor table of constants and prototype (to avoid being collected) */
349 sethvalue2s(L, L->top, fs->h);
350 incr_top(L);
351 setptvalue2s(L, L->top, f);
352 incr_top(L);
353}
354
355
356static void close_func (LexState *ls) {
357 lua_State *L = ls->L;
358 FuncState *fs = ls->fs;
359 Proto *f = fs->f;
360 removevars(ls, 0);
361 luaK_ret(fs, 0, 0); /* final return */
362 luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
363 f->sizecode = fs->pc;
364 luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
365 f->sizelineinfo = fs->pc;
366 luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
367 f->sizek = fs->nk;
368 luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
369 f->sizep = fs->np;
370 luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
371 f->sizelocvars = fs->nlocvars;
372 luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);
373 f->sizeupvalues = f->nups;
374 lua_assert(luaG_checkcode(f));
375 lua_assert(fs->bl == NULL);
376 ls->fs = fs->prev;
377 L->top -= 2; /* remove table and prototype from the stack */
378 /* last token read was anchored in defunct function; must reanchor it */
379 if (fs) anchor_token(ls);
380}
381
382
383Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
384 struct LexState lexstate;
385 struct FuncState funcstate;
386 lexstate.buff = buff;
387 luaX_setinput(L, &lexstate, z, luaS_new(L, name));
388 open_func(&lexstate, &funcstate);
389 funcstate.f->is_vararg = VARARG_ISVARARG; /* main func. is always vararg */
390 luaX_next(&lexstate); /* read first token */
391 chunk(&lexstate);
392 check(&lexstate, TK_EOS);
393 close_func(&lexstate);
394 lua_assert(funcstate.prev == NULL);
395 lua_assert(funcstate.f->nups == 0);
396 lua_assert(lexstate.fs == NULL);
397 return funcstate.f;
398}
399
400
401
402/*============================================================*/
403/* GRAMMAR RULES */
404/*============================================================*/
405
406
407static void field (LexState *ls, expdesc *v) {
408 /* field -> ['.' | ':'] NAME */
409 FuncState *fs = ls->fs;
410 expdesc key;
411 luaK_exp2anyreg(fs, v);
412 luaX_next(ls); /* skip the dot or colon */
413 checkname(ls, &key);
414 luaK_indexed(fs, v, &key);
415}
416
417
418static void yindex (LexState *ls, expdesc *v) {
419 /* index -> '[' expr ']' */
420 luaX_next(ls); /* skip the '[' */
421 expr(ls, v);
422 luaK_exp2val(ls->fs, v);
423 checknext(ls, ']');
424}
425
426
427/*
428** {======================================================================
429** Rules for Constructors
430** =======================================================================
431*/
432
433
434struct ConsControl {
435 expdesc v; /* last list item read */
436 expdesc *t; /* table descriptor */
437 int nh; /* total number of `record' elements */
438 int na; /* total number of array elements */
439 int tostore; /* number of array elements pending to be stored */
440};
441
442
443static void recfield (LexState *ls, struct ConsControl *cc) {
444 /* recfield -> (NAME | `['exp1`]') = exp1 */
445 FuncState *fs = ls->fs;
446 int reg = ls->fs->freereg;
447 expdesc key, val;
448 int rkkey;
449 if (ls->t.token == TK_NAME) {
450 luaY_checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
451 checkname(ls, &key);
452 }
453 else /* ls->t.token == '[' */
454 yindex(ls, &key);
455 cc->nh++;
456 checknext(ls, '=');
457 rkkey = luaK_exp2RK(fs, &key);
458 expr(ls, &val);
459 luaK_codeABC(fs, OP_SETTABLE, cc->t->u.s.info, rkkey, luaK_exp2RK(fs, &val));
460 fs->freereg = reg; /* free registers */
461}
462
463
464static void closelistfield (FuncState *fs, struct ConsControl *cc) {
465 if (cc->v.k == VVOID) return; /* there is no list item */
466 luaK_exp2nextreg(fs, &cc->v);
467 cc->v.k = VVOID;
468 if (cc->tostore == LFIELDS_PER_FLUSH) {
469 luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore); /* flush */
470 cc->tostore = 0; /* no more items pending */
471 }
472}
473
474
475static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
476 if (cc->tostore == 0) return;
477 if (hasmultret(cc->v.k)) {
478 luaK_setmultret(fs, &cc->v);
479 luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET);
480 cc->na--; /* do not count last expression (unknown number of elements) */
481 }
482 else {
483 if (cc->v.k != VVOID)
484 luaK_exp2nextreg(fs, &cc->v);
485 luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);
486 }
487}
488
489
490static void listfield (LexState *ls, struct ConsControl *cc) {
491 expr(ls, &cc->v);
492 luaY_checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
493 cc->na++;
494 cc->tostore++;
495}
496
497
498static void constructor (LexState *ls, expdesc *t) {
499 /* constructor -> ?? */
500 FuncState *fs = ls->fs;
501 int line = ls->linenumber;
502 int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
503 struct ConsControl cc;
504 cc.na = cc.nh = cc.tostore = 0;
505 cc.t = t;
506 init_exp(t, VRELOCABLE, pc);
507 init_exp(&cc.v, VVOID, 0); /* no value (yet) */
508 luaK_exp2nextreg(ls->fs, t); /* fix it at stack top (for gc) */
509 checknext(ls, '{');
510 do {
511 lua_assert(cc.v.k == VVOID || cc.tostore > 0);
512 if (ls->t.token == '}') break;
513 closelistfield(fs, &cc);
514 switch(ls->t.token) {
515 case TK_NAME: { /* may be listfields or recfields */
516 luaX_lookahead(ls);
517 if (ls->lookahead.token != '=') /* expression? */
518 listfield(ls, &cc);
519 else
520 recfield(ls, &cc);
521 break;
522 }
523 case '[': { /* constructor_item -> recfield */
524 recfield(ls, &cc);
525 break;
526 }
527 default: { /* constructor_part -> listfield */
528 listfield(ls, &cc);
529 break;
530 }
531 }
532 } while (testnext(ls, ',') || testnext(ls, ';'));
533 check_match(ls, '}', '{', line);
534 lastlistfield(fs, &cc);
535 SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */
536 SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh)); /* set initial table size */
537}
538
539/* }====================================================================== */
540
541
542
543static void parlist (LexState *ls) {
544 /* parlist -> [ param { `,' param } ] */
545 FuncState *fs = ls->fs;
546 Proto *f = fs->f;
547 int nparams = 0;
548 f->is_vararg = 0;
549 if (ls->t.token != ')') { /* is `parlist' not empty? */
550 do {
551 switch (ls->t.token) {
552 case TK_NAME: { /* param -> NAME */
553 new_localvar(ls, str_checkname(ls), nparams++);
554 break;
555 }
556 case TK_DOTS: { /* param -> `...' */
557 luaX_next(ls);
558#if defined(LUA_COMPAT_VARARG)
559 /* use `arg' as default name */
560 new_localvarliteral(ls, "arg", nparams++);
561 f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;
562#endif
563 f->is_vararg |= VARARG_ISVARARG;
564 break;
565 }
566 default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");
567 }
568 } while (!f->is_vararg && testnext(ls, ','));
569 }
570 adjustlocalvars(ls, nparams);
571 f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));
572 luaK_reserveregs(fs, fs->nactvar); /* reserve register for parameters */
573}
574
575
576static void body (LexState *ls, expdesc *e, int needself, int line) {
577 /* body -> `(' parlist `)' chunk END */
578 FuncState new_fs;
579 open_func(ls, &new_fs);
580 new_fs.f->linedefined = line;
581 checknext(ls, '(');
582 if (needself) {
583 new_localvarliteral(ls, "self", 0);
584 adjustlocalvars(ls, 1);
585 }
586 parlist(ls);
587 checknext(ls, ')');
588 chunk(ls);
589 new_fs.f->lastlinedefined = ls->linenumber;
590 check_match(ls, TK_END, TK_FUNCTION, line);
591 close_func(ls);
592 pushclosure(ls, &new_fs, e);
593}
594
595
596static int explist1 (LexState *ls, expdesc *v) {
597 /* explist1 -> expr { `,' expr } */
598 int n = 1; /* at least one expression */
599 expr(ls, v);
600 while (testnext(ls, ',')) {
601 luaK_exp2nextreg(ls->fs, v);
602 expr(ls, v);
603 n++;
604 }
605 return n;
606}
607
608
609static void funcargs (LexState *ls, expdesc *f) {
610 FuncState *fs = ls->fs;
611 expdesc args;
612 int base, nparams;
613 int line = ls->linenumber;
614 switch (ls->t.token) {
615 case '(': { /* funcargs -> `(' [ explist1 ] `)' */
616 if (line != ls->lastline)
617 luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
618 luaX_next(ls);
619 if (ls->t.token == ')') /* arg list is empty? */
620 args.k = VVOID;
621 else {
622 explist1(ls, &args);
623 luaK_setmultret(fs, &args);
624 }
625 check_match(ls, ')', '(', line);
626 break;
627 }
628 case '{': { /* funcargs -> constructor */
629 constructor(ls, &args);
630 break;
631 }
632 case TK_STRING: { /* funcargs -> STRING */
633 codestring(ls, &args, ls->t.seminfo.ts);
634 luaX_next(ls); /* must use `seminfo' before `next' */
635 break;
636 }
637 default: {
638 luaX_syntaxerror(ls, "function arguments expected");
639 return;
640 }
641 }
642 lua_assert(f->k == VNONRELOC);
643 base = f->u.s.info; /* base register for call */
644 if (hasmultret(args.k))
645 nparams = LUA_MULTRET; /* open call */
646 else {
647 if (args.k != VVOID)
648 luaK_exp2nextreg(fs, &args); /* close last argument */
649 nparams = fs->freereg - (base+1);
650 }
651 init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
652 luaK_fixline(fs, line);
653 fs->freereg = base+1; /* call remove function and arguments and leaves
654 (unless changed) one result */
655}
656
657
658
659
660/*
661** {======================================================================
662** Expression parsing
663** =======================================================================
664*/
665
666
667static void prefixexp (LexState *ls, expdesc *v) {
668 /* prefixexp -> NAME | '(' expr ')' */
669 switch (ls->t.token) {
670 case '(': {
671 int line = ls->linenumber;
672 luaX_next(ls);
673 expr(ls, v);
674 check_match(ls, ')', '(', line);
675 luaK_dischargevars(ls->fs, v);
676 return;
677 }
678 case TK_NAME: {
679 singlevar(ls, v);
680 return;
681 }
682 default: {
683 luaX_syntaxerror(ls, "unexpected symbol");
684 return;
685 }
686 }
687}
688
689
690static void primaryexp (LexState *ls, expdesc *v) {
691 /* primaryexp ->
692 prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs } */
693 FuncState *fs = ls->fs;
694 prefixexp(ls, v);
695 for (;;) {
696 switch (ls->t.token) {
697 case '.': { /* field */
698 field(ls, v);
699 break;
700 }
701 case '[': { /* `[' exp1 `]' */
702 expdesc key;
703 luaK_exp2anyreg(fs, v);
704 yindex(ls, &key);
705 luaK_indexed(fs, v, &key);
706 break;
707 }
708 case ':': { /* `:' NAME funcargs */
709 expdesc key;
710 luaX_next(ls);
711 checkname(ls, &key);
712 luaK_self(fs, v, &key);
713 funcargs(ls, v);
714 break;
715 }
716 case '(': case TK_STRING: case '{': { /* funcargs */
717 luaK_exp2nextreg(fs, v);
718 funcargs(ls, v);
719 break;
720 }
721 default: return;
722 }
723 }
724}
725
726
727static void simpleexp (LexState *ls, expdesc *v) {
728 /* simpleexp -> NUMBER | STRING | NIL | true | false | ... |
729 constructor | FUNCTION body | primaryexp */
730 switch (ls->t.token) {
731 case TK_NUMBER: {
732 init_exp(v, VKNUM, 0);
733 v->u.nval = ls->t.seminfo.r;
734 break;
735 }
736 case TK_STRING: {
737 codestring(ls, v, ls->t.seminfo.ts);
738 break;
739 }
740 case TK_NIL: {
741 init_exp(v, VNIL, 0);
742 break;
743 }
744 case TK_TRUE: {
745 init_exp(v, VTRUE, 0);
746 break;
747 }
748 case TK_FALSE: {
749 init_exp(v, VFALSE, 0);
750 break;
751 }
752 case TK_DOTS: { /* vararg */
753 FuncState *fs = ls->fs;
754 check_condition(ls, fs->f->is_vararg,
755 "cannot use " LUA_QL("...") " outside a vararg function");
756 fs->f->is_vararg &= ~VARARG_NEEDSARG; /* don't need 'arg' */
757 init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
758 break;
759 }
760 case '{': { /* constructor */
761 constructor(ls, v);
762 return;
763 }
764 case TK_FUNCTION: {
765 luaX_next(ls);
766 body(ls, v, 0, ls->linenumber);
767 return;
768 }
769 default: {
770 primaryexp(ls, v);
771 return;
772 }
773 }
774 luaX_next(ls);
775}
776
777
778static UnOpr getunopr (int op) {
779 switch (op) {
780 case TK_NOT: return OPR_NOT;
781 case '-': return OPR_MINUS;
782 case '#': return OPR_LEN;
783 default: return OPR_NOUNOPR;
784 }
785}
786
787
788static BinOpr getbinopr (int op) {
789 switch (op) {
790 case '+': return OPR_ADD;
791 case '-': return OPR_SUB;
792 case '*': return OPR_MUL;
793 case '/': return OPR_DIV;
794 case '%': return OPR_MOD;
795 case '^': return OPR_POW;
796 case TK_CONCAT: return OPR_CONCAT;
797 case TK_NE: return OPR_NE;
798 case TK_EQ: return OPR_EQ;
799 case '<': return OPR_LT;
800 case TK_LE: return OPR_LE;
801 case '>': return OPR_GT;
802 case TK_GE: return OPR_GE;
803 case TK_AND: return OPR_AND;
804 case TK_OR: return OPR_OR;
805 default: return OPR_NOBINOPR;
806 }
807}
808
809
810static const struct {
811 lu_byte left; /* left priority for each binary operator */
812 lu_byte right; /* right priority */
813} priority[] = { /* ORDER OPR */
814 {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7}, /* `+' `-' `/' `%' */
815 {10, 9}, {5, 4}, /* power and concat (right associative) */
816 {3, 3}, {3, 3}, /* equality and inequality */
817 {3, 3}, {3, 3}, {3, 3}, {3, 3}, /* order */
818 {2, 2}, {1, 1} /* logical (and/or) */
819};
820
821#define UNARY_PRIORITY 8 /* priority for unary operators */
822
823
824/*
825** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
826** where `binop' is any binary operator with a priority higher than `limit'
827*/
828static BinOpr subexpr (LexState *ls, expdesc *v, unsigned int limit) {
829 BinOpr op;
830 UnOpr uop;
831 enterlevel(ls);
832 uop = getunopr(ls->t.token);
833 if (uop != OPR_NOUNOPR) {
834 luaX_next(ls);
835 subexpr(ls, v, UNARY_PRIORITY);
836 luaK_prefix(ls->fs, uop, v);
837 }
838 else simpleexp(ls, v);
839 /* expand while operators have priorities higher than `limit' */
840 op = getbinopr(ls->t.token);
841 while (op != OPR_NOBINOPR && priority[op].left > limit) {
842 expdesc v2;
843 BinOpr nextop;
844 luaX_next(ls);
845 luaK_infix(ls->fs, op, v);
846 /* read sub-expression with higher priority */
847 nextop = subexpr(ls, &v2, priority[op].right);
848 luaK_posfix(ls->fs, op, v, &v2);
849 op = nextop;
850 }
851 leavelevel(ls);
852 return op; /* return first untreated operator */
853}
854
855
856static void expr (LexState *ls, expdesc *v) {
857 subexpr(ls, v, 0);
858}
859
860/* }==================================================================== */
861
862
863
864/*
865** {======================================================================
866** Rules for Statements
867** =======================================================================
868*/
869
870
871static int block_follow (int token) {
872 switch (token) {
873 case TK_ELSE: case TK_ELSEIF: case TK_END:
874 case TK_UNTIL: case TK_EOS:
875 return 1;
876 default: return 0;
877 }
878}
879
880
881static void block (LexState *ls) {
882 /* block -> chunk */
883 FuncState *fs = ls->fs;
884 BlockCnt bl;
885 enterblock(fs, &bl, 0);
886 chunk(ls);
887 lua_assert(bl.breaklist == NO_JUMP);
888 leaveblock(fs);
889}
890
891
892/*
893** structure to chain all variables in the left-hand side of an
894** assignment
895*/
896struct LHS_assign {
897 struct LHS_assign *prev;
898 expdesc v; /* variable (global, local, upvalue, or indexed) */
899};
900
901
902/*
903** check whether, in an assignment to a local variable, the local variable
904** is needed in a previous assignment (to a table). If so, save original
905** local value in a safe place and use this safe copy in the previous
906** assignment.
907*/
908static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
909 FuncState *fs = ls->fs;
910 int extra = fs->freereg; /* eventual position to save local variable */
911 int conflict = 0;
912 for (; lh; lh = lh->prev) {
913 if (lh->v.k == VINDEXED) {
914 if (lh->v.u.s.info == v->u.s.info) { /* conflict? */
915 conflict = 1;
916 lh->v.u.s.info = extra; /* previous assignment will use safe copy */
917 }
918 if (lh->v.u.s.aux == v->u.s.info) { /* conflict? */
919 conflict = 1;
920 lh->v.u.s.aux = extra; /* previous assignment will use safe copy */
921 }
922 }
923 }
924 if (conflict) {
925 luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0); /* make copy */
926 luaK_reserveregs(fs, 1);
927 }
928}
929
930
931static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
932 expdesc e;
933 check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED,
934 "syntax error");
935 if (testnext(ls, ',')) { /* assignment -> `,' primaryexp assignment */
936 struct LHS_assign nv;
937 nv.prev = lh;
938 primaryexp(ls, &nv.v);
939 if (nv.v.k == VLOCAL)
940 check_conflict(ls, lh, &nv.v);
941 luaY_checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls,
942 "variables in assignment");
943 assignment(ls, &nv, nvars+1);
944 }
945 else { /* assignment -> `=' explist1 */
946 int nexps;
947 checknext(ls, '=');
948 nexps = explist1(ls, &e);
949 if (nexps != nvars) {
950 adjust_assign(ls, nvars, nexps, &e);
951 if (nexps > nvars)
952 ls->fs->freereg -= nexps - nvars; /* remove extra values */
953 }
954 else {
955 luaK_setoneret(ls->fs, &e); /* close last expression */
956 luaK_storevar(ls->fs, &lh->v, &e);
957 return; /* avoid default */
958 }
959 }
960 init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */
961 luaK_storevar(ls->fs, &lh->v, &e);
962}
963
964
965static int cond (LexState *ls) {
966 /* cond -> exp */
967 expdesc v;
968 expr(ls, &v); /* read condition */
969 if (v.k == VNIL) v.k = VFALSE; /* `falses' are all equal here */
970 luaK_goiftrue(ls->fs, &v);
971 return v.f;
972}
973
974
975static void breakstat (LexState *ls) {
976 FuncState *fs = ls->fs;
977 BlockCnt *bl = fs->bl;
978 int upval = 0;
979 while (bl && !bl->isbreakable) {
980 upval |= bl->upval;
981 bl = bl->previous;
982 }
983 if (!bl)
984 luaX_syntaxerror(ls, "no loop to break");
985 if (upval)
986 luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
987 luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
988}
989
990
991static void whilestat (LexState *ls, int line) {
992 /* whilestat -> WHILE cond DO block END */
993 FuncState *fs = ls->fs;
994 int whileinit;
995 int condexit;
996 BlockCnt bl;
997 luaX_next(ls); /* skip WHILE */
998 whileinit = luaK_getlabel(fs);
999 condexit = cond(ls);
1000 enterblock(fs, &bl, 1);
1001 checknext(ls, TK_DO);
1002 block(ls);
1003 luaK_patchlist(fs, luaK_jump(fs), whileinit);
1004 check_match(ls, TK_END, TK_WHILE, line);
1005 leaveblock(fs);
1006 luaK_patchtohere(fs, condexit); /* false conditions finish the loop */
1007}
1008
1009
1010static void repeatstat (LexState *ls, int line) {
1011 /* repeatstat -> REPEAT block UNTIL cond */
1012 int condexit;
1013 FuncState *fs = ls->fs;
1014 int repeat_init = luaK_getlabel(fs);
1015 BlockCnt bl1, bl2;
1016 enterblock(fs, &bl1, 1); /* loop block */
1017 enterblock(fs, &bl2, 0); /* scope block */
1018 luaX_next(ls); /* skip REPEAT */
1019 chunk(ls);
1020 check_match(ls, TK_UNTIL, TK_REPEAT, line);
1021 condexit = cond(ls); /* read condition (inside scope block) */
1022 if (!bl2.upval) { /* no upvalues? */
1023 leaveblock(fs); /* finish scope */
1024 luaK_patchlist(ls->fs, condexit, repeat_init); /* close the loop */
1025 }
1026 else { /* complete semantics when there are upvalues */
1027 breakstat(ls); /* if condition then break */
1028 luaK_patchtohere(ls->fs, condexit); /* else... */
1029 leaveblock(fs); /* finish scope... */
1030 luaK_patchlist(ls->fs, luaK_jump(fs), repeat_init); /* and repeat */
1031 }
1032 leaveblock(fs); /* finish loop */
1033}
1034
1035
1036static int exp1 (LexState *ls) {
1037 expdesc e;
1038 int k;
1039 expr(ls, &e);
1040 k = e.k;
1041 luaK_exp2nextreg(ls->fs, &e);
1042 return k;
1043}
1044
1045
1046static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
1047 /* forbody -> DO block */
1048 BlockCnt bl;
1049 FuncState *fs = ls->fs;
1050 int prep, endfor;
1051 adjustlocalvars(ls, 3); /* control variables */
1052 checknext(ls, TK_DO);
1053 prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
1054 enterblock(fs, &bl, 0); /* scope for declared variables */
1055 adjustlocalvars(ls, nvars);
1056 luaK_reserveregs(fs, nvars);
1057 block(ls);
1058 leaveblock(fs); /* end of scope for declared variables */
1059 luaK_patchtohere(fs, prep);
1060 endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :
1061 luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);
1062 luaK_fixline(fs, line); /* pretend that `OP_FOR' starts the loop */
1063 luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);
1064}
1065
1066
1067static void fornum (LexState *ls, TString *varname, int line) {
1068 /* fornum -> NAME = exp1,exp1[,exp1] forbody */
1069 FuncState *fs = ls->fs;
1070 int base = fs->freereg;
1071 new_localvarliteral(ls, "(for index)", 0);
1072 new_localvarliteral(ls, "(for limit)", 1);
1073 new_localvarliteral(ls, "(for step)", 2);
1074 new_localvar(ls, varname, 3);
1075 checknext(ls, '=');
1076 exp1(ls); /* initial value */
1077 checknext(ls, ',');
1078 exp1(ls); /* limit */
1079 if (testnext(ls, ','))
1080 exp1(ls); /* optional step */
1081 else { /* default step = 1 */
1082 luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1));
1083 luaK_reserveregs(fs, 1);
1084 }
1085 forbody(ls, base, line, 1, 1);
1086}
1087
1088
1089static void forlist (LexState *ls, TString *indexname) {
1090 /* forlist -> NAME {,NAME} IN explist1 forbody */
1091 FuncState *fs = ls->fs;
1092 expdesc e;
1093 int nvars = 0;
1094 int line;
1095 int base = fs->freereg;
1096 /* create control variables */
1097 new_localvarliteral(ls, "(for generator)", nvars++);
1098 new_localvarliteral(ls, "(for state)", nvars++);
1099 new_localvarliteral(ls, "(for control)", nvars++);
1100 /* create declared variables */
1101 new_localvar(ls, indexname, nvars++);
1102 while (testnext(ls, ','))
1103 new_localvar(ls, str_checkname(ls), nvars++);
1104 checknext(ls, TK_IN);
1105 line = ls->linenumber;
1106 adjust_assign(ls, 3, explist1(ls, &e), &e);
1107 luaK_checkstack(fs, 3); /* extra space to call generator */
1108 forbody(ls, base, line, nvars - 3, 0);
1109}
1110
1111
1112static void forstat (LexState *ls, int line) {
1113 /* forstat -> FOR (fornum | forlist) END */
1114 FuncState *fs = ls->fs;
1115 TString *varname;
1116 BlockCnt bl;
1117 enterblock(fs, &bl, 1); /* scope for loop and control variables */
1118 luaX_next(ls); /* skip `for' */
1119 varname = str_checkname(ls); /* first variable name */
1120 switch (ls->t.token) {
1121 case '=': fornum(ls, varname, line); break;
1122 case ',': case TK_IN: forlist(ls, varname); break;
1123 default: luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected");
1124 }
1125 check_match(ls, TK_END, TK_FOR, line);
1126 leaveblock(fs); /* loop scope (`break' jumps to this point) */
1127}
1128
1129
1130static int test_then_block (LexState *ls) {
1131 /* test_then_block -> [IF | ELSEIF] cond THEN block */
1132 int condexit;
1133 luaX_next(ls); /* skip IF or ELSEIF */
1134 condexit = cond(ls);
1135 checknext(ls, TK_THEN);
1136 block(ls); /* `then' part */
1137 return condexit;
1138}
1139
1140
1141static void ifstat (LexState *ls, int line) {
1142 /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
1143 FuncState *fs = ls->fs;
1144 int flist;
1145 int escapelist = NO_JUMP;
1146 flist = test_then_block(ls); /* IF cond THEN block */
1147 while (ls->t.token == TK_ELSEIF) {
1148 luaK_concat(fs, &escapelist, luaK_jump(fs));
1149 luaK_patchtohere(fs, flist);
1150 flist = test_then_block(ls); /* ELSEIF cond THEN block */
1151 }
1152 if (ls->t.token == TK_ELSE) {
1153 luaK_concat(fs, &escapelist, luaK_jump(fs));
1154 luaK_patchtohere(fs, flist);
1155 luaX_next(ls); /* skip ELSE (after patch, for correct line info) */
1156 block(ls); /* `else' part */
1157 }
1158 else
1159 luaK_concat(fs, &escapelist, flist);
1160 luaK_patchtohere(fs, escapelist);
1161 check_match(ls, TK_END, TK_IF, line);
1162}
1163
1164
1165static void localfunc (LexState *ls) {
1166 expdesc v, b;
1167 FuncState *fs = ls->fs;
1168 new_localvar(ls, str_checkname(ls), 0);
1169 init_exp(&v, VLOCAL, fs->freereg);
1170 luaK_reserveregs(fs, 1);
1171 adjustlocalvars(ls, 1);
1172 body(ls, &b, 0, ls->linenumber);
1173 luaK_storevar(fs, &v, &b);
1174 /* debug information will only see the variable after this point! */
1175 getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
1176}
1177
1178
1179static void localstat (LexState *ls) {
1180 /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */
1181 int nvars = 0;
1182 int nexps;
1183 expdesc e;
1184 do {
1185 new_localvar(ls, str_checkname(ls), nvars++);
1186 } while (testnext(ls, ','));
1187 if (testnext(ls, '='))
1188 nexps = explist1(ls, &e);
1189 else {
1190 e.k = VVOID;
1191 nexps = 0;
1192 }
1193 adjust_assign(ls, nvars, nexps, &e);
1194 adjustlocalvars(ls, nvars);
1195}
1196
1197
1198static int funcname (LexState *ls, expdesc *v) {
1199 /* funcname -> NAME {field} [`:' NAME] */
1200 int needself = 0;
1201 singlevar(ls, v);
1202 while (ls->t.token == '.')
1203 field(ls, v);
1204 if (ls->t.token == ':') {
1205 needself = 1;
1206 field(ls, v);
1207 }
1208 return needself;
1209}
1210
1211
1212static void funcstat (LexState *ls, int line) {
1213 /* funcstat -> FUNCTION funcname body */
1214 int needself;
1215 expdesc v, b;
1216 luaX_next(ls); /* skip FUNCTION */
1217 needself = funcname(ls, &v);
1218 body(ls, &b, needself, line);
1219 luaK_storevar(ls->fs, &v, &b);
1220 luaK_fixline(ls->fs, line); /* definition `happens' in the first line */
1221}
1222
1223
1224static void exprstat (LexState *ls) {
1225 /* stat -> func | assignment */
1226 FuncState *fs = ls->fs;
1227 struct LHS_assign v;
1228 primaryexp(ls, &v.v);
1229 if (v.v.k == VCALL) /* stat -> func */
1230 SETARG_C(getcode(fs, &v.v), 1); /* call statement uses no results */
1231 else { /* stat -> assignment */
1232 v.prev = NULL;
1233 assignment(ls, &v, 1);
1234 }
1235}
1236
1237
1238static void retstat (LexState *ls) {
1239 /* stat -> RETURN explist */
1240 FuncState *fs = ls->fs;
1241 expdesc e;
1242 int first, nret; /* registers with returned values */
1243 luaX_next(ls); /* skip RETURN */
1244 if (block_follow(ls->t.token) || ls->t.token == ';')
1245 first = nret = 0; /* return no values */
1246 else {
1247 nret = explist1(ls, &e); /* optional return values */
1248 if (hasmultret(e.k)) {
1249 luaK_setmultret(fs, &e);
1250 if (e.k == VCALL && nret == 1) { /* tail call? */
1251 SET_OPCODE(getcode(fs,&e), OP_TAILCALL);
1252 lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar);
1253 }
1254 first = fs->nactvar;
1255 nret = LUA_MULTRET; /* return all values */
1256 }
1257 else {
1258 if (nret == 1) /* only one single value? */
1259 first = luaK_exp2anyreg(fs, &e);
1260 else {
1261 luaK_exp2nextreg(fs, &e); /* values must go to the `stack' */
1262 first = fs->nactvar; /* return all `active' values */
1263 lua_assert(nret == fs->freereg - first);
1264 }
1265 }
1266 }
1267 luaK_ret(fs, first, nret);
1268}
1269
1270
1271static int statement (LexState *ls) {
1272 int line = ls->linenumber; /* may be needed for error messages */
1273 switch (ls->t.token) {
1274 case TK_IF: { /* stat -> ifstat */
1275 ifstat(ls, line);
1276 return 0;
1277 }
1278 case TK_WHILE: { /* stat -> whilestat */
1279 whilestat(ls, line);
1280 return 0;
1281 }
1282 case TK_DO: { /* stat -> DO block END */
1283 luaX_next(ls); /* skip DO */
1284 block(ls);
1285 check_match(ls, TK_END, TK_DO, line);
1286 return 0;
1287 }
1288 case TK_FOR: { /* stat -> forstat */
1289 forstat(ls, line);
1290 return 0;
1291 }
1292 case TK_REPEAT: { /* stat -> repeatstat */
1293 repeatstat(ls, line);
1294 return 0;
1295 }
1296 case TK_FUNCTION: {
1297 funcstat(ls, line); /* stat -> funcstat */
1298 return 0;
1299 }
1300 case TK_LOCAL: { /* stat -> localstat */
1301 luaX_next(ls); /* skip LOCAL */
1302 if (testnext(ls, TK_FUNCTION)) /* local function? */
1303 localfunc(ls);
1304 else
1305 localstat(ls);
1306 return 0;
1307 }
1308 case TK_RETURN: { /* stat -> retstat */
1309 retstat(ls);
1310 return 1; /* must be last statement */
1311 }
1312 case TK_BREAK: { /* stat -> breakstat */
1313 luaX_next(ls); /* skip BREAK */
1314 breakstat(ls);
1315 return 1; /* must be last statement */
1316 }
1317 default: {
1318 exprstat(ls);
1319 return 0; /* to avoid warnings */
1320 }
1321 }
1322}
1323
1324
1325static void chunk (LexState *ls) {
1326 /* chunk -> { stat [`;'] } */
1327 int islast = 0;
1328 enterlevel(ls);
1329 while (!islast && !block_follow(ls->t.token)) {
1330 islast = statement(ls);
1331 testnext(ls, ';');
1332 lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
1333 ls->fs->freereg >= ls->fs->nactvar);
1334 ls->fs->freereg = ls->fs->nactvar; /* free registers */
1335 }
1336 leavelevel(ls);
1337}
1338
1339/* }====================================================================== */
diff --git a/libraries/LuaJIT-1.1.7/src/lparser.h b/libraries/LuaJIT-1.1.7/src/lparser.h
new file mode 100644
index 0000000..18836af
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lparser.h
@@ -0,0 +1,82 @@
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
19typedef 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
37typedef 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
48typedef struct upvaldesc {
49 lu_byte k;
50 lu_byte info;
51} upvaldesc;
52
53
54struct BlockCnt; /* defined in lparser.c */
55
56
57/* state needed to generate code for a given function */
58typedef 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
78LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
79 const char *name);
80
81
82#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lstate.c b/libraries/LuaJIT-1.1.7/src/lstate.c
new file mode 100644
index 0000000..2bf835b
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lstate.c
@@ -0,0 +1,218 @@
1/*
2** $Id: lstate.c,v 2.36.1.2 2008/01/03 15:20:39 roberto Exp $
3** Global State
4** See Copyright Notice in lua.h
5*/
6
7
8#include <stddef.h>
9
10#define lstate_c
11#define LUA_CORE
12
13#include "lua.h"
14
15#include "ldebug.h"
16#include "ldo.h"
17#include "lfunc.h"
18#include "lgc.h"
19#include "llex.h"
20#include "lmem.h"
21#include "lstate.h"
22#include "lstring.h"
23#include "ltable.h"
24#include "ltm.h"
25#include "ljit.h"
26
27
28#define state_size(x) (sizeof(x) + LUAI_EXTRASPACE)
29#define fromstate(l) (cast(lu_byte *, (l)) - LUAI_EXTRASPACE)
30#define tostate(l) (cast(lua_State *, cast(lu_byte *, l) + LUAI_EXTRASPACE))
31
32
33/*
34** Main thread combines a thread state and the global state
35*/
36typedef struct LG {
37 lua_State l;
38 global_State g;
39} LG;
40
41
42
43static void stack_init (lua_State *L1, lua_State *L) {
44 /* initialize CallInfo array */
45 L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
46 L1->ci = L1->base_ci;
47 L1->size_ci = BASIC_CI_SIZE;
48 L1->end_ci = L1->base_ci + L1->size_ci - 1;
49 /* initialize stack array */
50 L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);
51 L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
52 L1->top = L1->stack;
53 L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
54 /* initialize first ci */
55 L1->ci->func = L1->top;
56 setnilvalue(L1->top++); /* `function' entry for this `ci' */
57 L1->base = L1->ci->base = L1->top;
58 L1->ci->top = L1->top + LUA_MINSTACK;
59}
60
61
62static void freestack (lua_State *L, lua_State *L1) {
63 luaM_freearray(L, L1->base_ci, L1->size_ci, CallInfo);
64 luaM_freearray(L, L1->stack, L1->stacksize, TValue);
65}
66
67
68/*
69** open parts that may cause memory-allocation errors
70*/
71static void f_luaopen (lua_State *L, void *ud) {
72 global_State *g = G(L);
73 UNUSED(ud);
74 stack_init(L, L); /* init stack */
75 sethvalue(L, gt(L), luaH_new(L, 0, 2)); /* table of globals */
76 sethvalue(L, registry(L), luaH_new(L, 0, 2)); /* registry */
77 luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */
78 luaT_init(L);
79 luaX_init(L);
80 luaS_fix(luaS_newliteral(L, MEMERRMSG));
81 g->GCthreshold = 4*g->totalbytes;
82 luaJIT_initstate(L);
83}
84
85
86static void preinit_state (lua_State *L, global_State *g) {
87 G(L) = g;
88 L->stack = NULL;
89 L->stacksize = 0;
90 L->errorJmp = NULL;
91 L->hook = NULL;
92 L->hookmask = 0;
93 L->basehookcount = 0;
94 L->allowhook = 1;
95 resethookcount(L);
96 L->openupval = NULL;
97 L->size_ci = 0;
98 L->nCcalls = 0;
99 L->status = 0;
100 L->base_ci = L->ci = NULL;
101 L->savedpc = NULL;
102 L->errfunc = 0;
103 setnilvalue(gt(L));
104}
105
106
107static void close_state (lua_State *L) {
108 global_State *g = G(L);
109 luaF_close(L, L->stack); /* close all upvalues for this thread */
110 luaC_freeall(L); /* collect all objects */
111 luaJIT_freestate(L);
112 lua_assert(g->rootgc == obj2gco(L));
113 lua_assert(g->strt.nuse == 0);
114 luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
115 luaZ_freebuffer(L, &g->buff);
116 freestack(L, L);
117 lua_assert(g->totalbytes == sizeof(LG));
118 (*g->frealloc)(g->ud, fromstate(L), state_size(LG), 0);
119}
120
121
122lua_State *luaE_newthread (lua_State *L) {
123 lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));
124 luaC_link(L, obj2gco(L1), LUA_TTHREAD);
125 preinit_state(L1, G(L));
126 stack_init(L1, L); /* init stack */
127 setobj2n(L, gt(L1), gt(L)); /* share table of globals */
128 L1->hookmask = L->hookmask;
129 L1->basehookcount = L->basehookcount;
130 L1->hook = L->hook;
131 resethookcount(L1);
132 lua_assert(iswhite(obj2gco(L1)));
133 return L1;
134}
135
136
137void luaE_freethread (lua_State *L, lua_State *L1) {
138 luaF_close(L1, L1->stack); /* close all upvalues for this thread */
139 lua_assert(L1->openupval == NULL);
140 luai_userstatefree(L1);
141 freestack(L, L1);
142 luaM_freemem(L, fromstate(L1), state_size(lua_State));
143}
144
145
146LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
147 int i;
148 lua_State *L;
149 global_State *g;
150 void *l = (*f)(ud, NULL, 0, state_size(LG));
151 if (l == NULL) return NULL;
152 L = tostate(l);
153 g = &((LG *)L)->g;
154 L->next = NULL;
155 L->tt = LUA_TTHREAD;
156 g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
157 L->marked = luaC_white(g);
158 set2bits(L->marked, FIXEDBIT, SFIXEDBIT);
159 preinit_state(L, g);
160 g->frealloc = f;
161 g->ud = ud;
162 g->mainthread = L;
163 g->uvhead.u.l.prev = &g->uvhead;
164 g->uvhead.u.l.next = &g->uvhead;
165 g->GCthreshold = 0; /* mark it as unfinished state */
166 g->strt.size = 0;
167 g->strt.nuse = 0;
168 g->strt.hash = NULL;
169 setnilvalue(registry(L));
170 luaZ_initbuffer(L, &g->buff);
171 g->panic = NULL;
172 g->gcstate = GCSpause;
173 g->rootgc = obj2gco(L);
174 g->sweepstrgc = 0;
175 g->sweepgc = &g->rootgc;
176 g->gray = NULL;
177 g->grayagain = NULL;
178 g->weak = NULL;
179 g->tmudata = NULL;
180 g->totalbytes = sizeof(LG);
181 g->gcpause = LUAI_GCPAUSE;
182 g->gcstepmul = LUAI_GCMUL;
183 g->gcdept = 0;
184 g->jit_state = NULL;
185 for (i=0; i<NUM_TAGS; i++) g->mt[i] = NULL;
186 if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
187 /* memory allocation error: free partial state */
188 close_state(L);
189 L = NULL;
190 }
191 else
192 luai_userstateopen(L);
193 return L;
194}
195
196
197static void callallgcTM (lua_State *L, void *ud) {
198 UNUSED(ud);
199 luaC_callGCTM(L); /* call GC metamethods for all udata */
200}
201
202
203LUA_API void lua_close (lua_State *L) {
204 L = G(L)->mainthread; /* only the main thread can be closed */
205 lua_lock(L);
206 luaF_close(L, L->stack); /* close all upvalues for this thread */
207 luaC_separateudata(L, 1); /* separate udata that have GC metamethods */
208 L->errfunc = 0; /* no error function during GC metamethods */
209 do { /* repeat until no more errors */
210 L->ci = L->base_ci;
211 L->base = L->top = L->ci->base;
212 L->nCcalls = 0;
213 } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0);
214 lua_assert(G(L)->tmudata == NULL);
215 luai_userstateclose(L);
216 close_state(L);
217}
218
diff --git a/libraries/LuaJIT-1.1.7/src/lstate.h b/libraries/LuaJIT-1.1.7/src/lstate.h
new file mode 100644
index 0000000..ddaa554
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lstate.h
@@ -0,0 +1,179 @@
1/*
2** $Id: lstate.h,v 2.24.1.2 2008/01/03 15:20:39 roberto Exp $
3** Global State
4** See Copyright Notice in lua.h
5*/
6
7#ifndef lstate_h
8#define lstate_h
9
10#include "lua.h"
11
12#include "lobject.h"
13#include "ltm.h"
14#include "lzio.h"
15#ifndef COCO_DISABLE
16#include "lcoco.h"
17#endif
18
19
20
21struct lua_longjmp; /* defined in ldo.c */
22struct jit_State; /* defined in ljit.c */
23typedef int (*luaJIT_GateLJ)(lua_State *L, StkId func, int nresults);
24
25
26/* table of globals */
27#define gt(L) (&L->l_gt)
28
29/* registry */
30#define registry(L) (&G(L)->l_registry)
31
32
33/* extra stack space to handle TM calls and some other extras */
34/* LuaJIT uses more than the default (5) to speed up calls (setnil loop) */
35#define EXTRA_STACK 8
36
37
38#define BASIC_CI_SIZE 8
39
40#define BASIC_STACK_SIZE (2*LUA_MINSTACK)
41
42
43
44typedef struct stringtable {
45 GCObject **hash;
46 lu_int32 nuse; /* number of elements */
47 int size;
48} stringtable;
49
50
51/*
52** informations about a call
53*/
54typedef struct CallInfo {
55 StkId base; /* base for this function */
56 StkId func; /* function index in the stack */
57 StkId top; /* top for this function */
58 const Instruction *savedpc;
59 int nresults; /* expected number of results from this function */
60 int tailcalls; /* number of tail calls lost under this entry */
61} CallInfo;
62
63
64
65#define curr_func(L) (clvalue(L->ci->func))
66#define ci_func(ci) (clvalue((ci)->func))
67#define f_isLua(ci) (!ci_func(ci)->c.isC)
68#define isLua(ci) (ttisfunction((ci)->func) && f_isLua(ci))
69
70
71/*
72** `global state', shared by all threads of this state
73*/
74typedef struct global_State {
75 stringtable strt; /* hash table for strings */
76 lua_Alloc frealloc; /* function to reallocate memory */
77 void *ud; /* auxiliary data to `frealloc' */
78 lu_byte currentwhite;
79 lu_byte gcstate; /* state of garbage collector */
80 int sweepstrgc; /* position of sweep in `strt' */
81 GCObject *rootgc; /* list of all collectable objects */
82 GCObject **sweepgc; /* position of sweep in `rootgc' */
83 GCObject *gray; /* list of gray objects */
84 GCObject *grayagain; /* list of objects to be traversed atomically */
85 GCObject *weak; /* list of weak tables (to be cleared) */
86 GCObject *tmudata; /* last element of list of userdata to be GC */
87 Mbuffer buff; /* temporary buffer for string concatentation */
88 lu_mem GCthreshold;
89 lu_mem totalbytes; /* number of bytes currently allocated */
90 lu_mem estimate; /* an estimate of number of bytes actually in use */
91 lu_mem gcdept; /* how much GC is `behind schedule' */
92 int gcpause; /* size of pause between successive GCs */
93 int gcstepmul; /* GC `granularity' */
94 lua_CFunction panic; /* to be called in unprotected errors */
95 TValue l_registry;
96 struct lua_State *mainthread;
97 UpVal uvhead; /* head of double-linked list of all open upvalues */
98 struct Table *mt[NUM_TAGS]; /* metatables for basic types */
99 TString *tmname[TM_N]; /* array with tag-method names */
100 /* LuaJIT extensions */
101 struct jit_State *jit_state; /* JIT state */
102 luaJIT_GateLJ jit_gateLJ; /* Lua -> JIT gate */
103 lua_CFunction jit_gateJL; /* JIT -> Lua callgate */
104 lua_CFunction jit_gateJC; /* JIT -> C callgate */
105} global_State;
106
107
108/*
109** `per thread' state
110*/
111struct lua_State {
112 CommonHeader;
113 lu_byte status;
114 StkId top; /* first free slot in the stack */
115 StkId base; /* base of current function */
116 global_State *l_G;
117 CallInfo *ci; /* call info for current function */
118 const Instruction *savedpc; /* `savedpc' of current function */
119 StkId stack_last; /* last free slot in the stack */
120 StkId stack; /* stack base */
121 CallInfo *end_ci; /* points after end of ci array*/
122 CallInfo *base_ci; /* array of CallInfo's */
123 int stacksize;
124 int size_ci; /* size of array `base_ci' */
125 unsigned short nCcalls; /* number of nested C calls */
126 lu_byte hookmask;
127 lu_byte allowhook;
128 int basehookcount;
129 int hookcount;
130 lua_Hook hook;
131 TValue l_gt; /* table of globals */
132 TValue env; /* temporary place for environments */
133 GCObject *openupval; /* list of open upvalues in this stack */
134 GCObject *gclist;
135 struct lua_longjmp *errorJmp; /* current error recover point */
136 ptrdiff_t errfunc; /* current error handling function (stack index) */
137};
138
139
140#define G(L) (L->l_G)
141
142
143/*
144** Union of all collectable objects
145*/
146union GCObject {
147 GCheader gch;
148 union TString ts;
149 union Udata u;
150 union Closure cl;
151 struct Table h;
152 struct Proto p;
153 struct UpVal uv;
154 struct lua_State th; /* thread */
155};
156
157
158/* macros to convert a GCObject into a specific value */
159#define rawgco2ts(o) check_exp((o)->gch.tt == LUA_TSTRING, &((o)->ts))
160#define gco2ts(o) (&rawgco2ts(o)->tsv)
161#define rawgco2u(o) check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))
162#define gco2u(o) (&rawgco2u(o)->uv)
163#define gco2cl(o) check_exp((o)->gch.tt == LUA_TFUNCTION, &((o)->cl))
164#define gco2h(o) check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
165#define gco2p(o) check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
166#define gco2uv(o) check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))
167#define ngcotouv(o) \
168 check_exp((o) == NULL || (o)->gch.tt == LUA_TUPVAL, &((o)->uv))
169#define gco2th(o) check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
170
171/* macro to convert any Lua object into a GCObject */
172#define obj2gco(v) (cast(GCObject *, (v)))
173
174
175LUAI_FUNC lua_State *luaE_newthread (lua_State *L);
176LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
177
178#endif
179
diff --git a/libraries/LuaJIT-1.1.7/src/lstring.c b/libraries/LuaJIT-1.1.7/src/lstring.c
new file mode 100644
index 0000000..4911315
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lstring.c
@@ -0,0 +1,111 @@
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
22void 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
50static 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
75TString *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
96Udata *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
diff --git a/libraries/LuaJIT-1.1.7/src/lstring.h b/libraries/LuaJIT-1.1.7/src/lstring.h
new file mode 100644
index 0000000..73a2ff8
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lstring.h
@@ -0,0 +1,31 @@
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
26LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
27LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);
28LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
29
30
31#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lstrlib.c b/libraries/LuaJIT-1.1.7/src/lstrlib.c
new file mode 100644
index 0000000..fe452ce
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lstrlib.c
@@ -0,0 +1,871 @@
1/*
2** $Id: lstrlib.c,v 1.132.1.4 2008/07/11 17:27:21 roberto Exp $
3** Standard library for string operations and pattern-matching
4** See Copyright Notice in lua.h
5*/
6
7
8#include <ctype.h>
9#include <stddef.h>
10#include <stdio.h>
11#include <stdlib.h>
12#include <string.h>
13
14#define lstrlib_c
15#define LUA_LIB
16
17#include "lua.h"
18
19#include "lauxlib.h"
20#include "lualib.h"
21
22
23/* macro to `unsign' a character */
24#define uchar(c) ((unsigned char)(c))
25
26
27
28static int str_len (lua_State *L) {
29 size_t l;
30 luaL_checklstring(L, 1, &l);
31 lua_pushinteger(L, l);
32 return 1;
33}
34
35
36static ptrdiff_t posrelat (ptrdiff_t pos, size_t len) {
37 /* relative string position: negative means back from end */
38 if (pos < 0) pos += (ptrdiff_t)len + 1;
39 return (pos >= 0) ? pos : 0;
40}
41
42
43static int str_sub (lua_State *L) {
44 size_t l;
45 const char *s = luaL_checklstring(L, 1, &l);
46 ptrdiff_t start = posrelat(luaL_checkinteger(L, 2), l);
47 ptrdiff_t end = posrelat(luaL_optinteger(L, 3, -1), l);
48 if (start < 1) start = 1;
49 if (end > (ptrdiff_t)l) end = (ptrdiff_t)l;
50 if (start <= end)
51 lua_pushlstring(L, s+start-1, end-start+1);
52 else lua_pushliteral(L, "");
53 return 1;
54}
55
56
57static int str_reverse (lua_State *L) {
58 size_t l;
59 luaL_Buffer b;
60 const char *s = luaL_checklstring(L, 1, &l);
61 luaL_buffinit(L, &b);
62 while (l--) luaL_addchar(&b, s[l]);
63 luaL_pushresult(&b);
64 return 1;
65}
66
67
68static int str_lower (lua_State *L) {
69 size_t l;
70 size_t i;
71 luaL_Buffer b;
72 const char *s = luaL_checklstring(L, 1, &l);
73 luaL_buffinit(L, &b);
74 for (i=0; i<l; i++)
75 luaL_addchar(&b, tolower(uchar(s[i])));
76 luaL_pushresult(&b);
77 return 1;
78}
79
80
81static int str_upper (lua_State *L) {
82 size_t l;
83 size_t i;
84 luaL_Buffer b;
85 const char *s = luaL_checklstring(L, 1, &l);
86 luaL_buffinit(L, &b);
87 for (i=0; i<l; i++)
88 luaL_addchar(&b, toupper(uchar(s[i])));
89 luaL_pushresult(&b);
90 return 1;
91}
92
93static int str_rep (lua_State *L) {
94 size_t l;
95 luaL_Buffer b;
96 const char *s = luaL_checklstring(L, 1, &l);
97 int n = luaL_checkint(L, 2);
98 luaL_buffinit(L, &b);
99 while (n-- > 0)
100 luaL_addlstring(&b, s, l);
101 luaL_pushresult(&b);
102 return 1;
103}
104
105
106static int str_byte (lua_State *L) {
107 size_t l;
108 const char *s = luaL_checklstring(L, 1, &l);
109 ptrdiff_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
110 ptrdiff_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
111 int n, i;
112 if (posi <= 0) posi = 1;
113 if ((size_t)pose > l) pose = l;
114 if (posi > pose) return 0; /* empty interval; return no values */
115 n = (int)(pose - posi + 1);
116 if (posi + n <= pose) /* overflow? */
117 luaL_error(L, "string slice too long");
118 luaL_checkstack(L, n, "string slice too long");
119 for (i=0; i<n; i++)
120 lua_pushinteger(L, uchar(s[posi+i-1]));
121 return n;
122}
123
124
125static int str_char (lua_State *L) {
126 int n = lua_gettop(L); /* number of arguments */
127 int i;
128 luaL_Buffer b;
129 luaL_buffinit(L, &b);
130 for (i=1; i<=n; i++) {
131 int c = luaL_checkint(L, i);
132 luaL_argcheck(L, uchar(c) == c, i, "invalid value");
133 luaL_addchar(&b, uchar(c));
134 }
135 luaL_pushresult(&b);
136 return 1;
137}
138
139
140static int writer (lua_State *L, const void* b, size_t size, void* B) {
141 (void)L;
142 luaL_addlstring((luaL_Buffer*) B, (const char *)b, size);
143 return 0;
144}
145
146
147static int str_dump (lua_State *L) {
148 luaL_Buffer b;
149 luaL_checktype(L, 1, LUA_TFUNCTION);
150 lua_settop(L, 1);
151 luaL_buffinit(L,&b);
152 if (lua_dump(L, writer, &b) != 0)
153 luaL_error(L, "unable to dump given function");
154 luaL_pushresult(&b);
155 return 1;
156}
157
158
159
160/*
161** {======================================================
162** PATTERN MATCHING
163** =======================================================
164*/
165
166
167#define CAP_UNFINISHED (-1)
168#define CAP_POSITION (-2)
169
170typedef struct MatchState {
171 const char *src_init; /* init of source string */
172 const char *src_end; /* end (`\0') of source string */
173 lua_State *L;
174 int level; /* total number of captures (finished or unfinished) */
175 struct {
176 const char *init;
177 ptrdiff_t len;
178 } capture[LUA_MAXCAPTURES];
179} MatchState;
180
181
182#define L_ESC '%'
183#define SPECIALS "^$*+?.([%-"
184
185
186static int check_capture (MatchState *ms, int l) {
187 l -= '1';
188 if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
189 return luaL_error(ms->L, "invalid capture index");
190 return l;
191}
192
193
194static int capture_to_close (MatchState *ms) {
195 int level = ms->level;
196 for (level--; level>=0; level--)
197 if (ms->capture[level].len == CAP_UNFINISHED) return level;
198 return luaL_error(ms->L, "invalid pattern capture");
199}
200
201
202static const char *classend (MatchState *ms, const char *p) {
203 switch (*p++) {
204 case L_ESC: {
205 if (*p == '\0')
206 luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
207 return p+1;
208 }
209 case '[': {
210 if (*p == '^') p++;
211 do { /* look for a `]' */
212 if (*p == '\0')
213 luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
214 if (*(p++) == L_ESC && *p != '\0')
215 p++; /* skip escapes (e.g. `%]') */
216 } while (*p != ']');
217 return p+1;
218 }
219 default: {
220 return p;
221 }
222 }
223}
224
225
226static int match_class (int c, int cl) {
227 int res;
228 switch (tolower(cl)) {
229 case 'a' : res = isalpha(c); break;
230 case 'c' : res = iscntrl(c); break;
231 case 'd' : res = isdigit(c); break;
232 case 'l' : res = islower(c); break;
233 case 'p' : res = ispunct(c); break;
234 case 's' : res = isspace(c); break;
235 case 'u' : res = isupper(c); break;
236 case 'w' : res = isalnum(c); break;
237 case 'x' : res = isxdigit(c); break;
238 case 'z' : res = (c == 0); break;
239 default: return (cl == c);
240 }
241 return (islower(cl) ? res : !res);
242}
243
244
245static int matchbracketclass (int c, const char *p, const char *ec) {
246 int sig = 1;
247 if (*(p+1) == '^') {
248 sig = 0;
249 p++; /* skip the `^' */
250 }
251 while (++p < ec) {
252 if (*p == L_ESC) {
253 p++;
254 if (match_class(c, uchar(*p)))
255 return sig;
256 }
257 else if ((*(p+1) == '-') && (p+2 < ec)) {
258 p+=2;
259 if (uchar(*(p-2)) <= c && c <= uchar(*p))
260 return sig;
261 }
262 else if (uchar(*p) == c) return sig;
263 }
264 return !sig;
265}
266
267
268static int singlematch (int c, const char *p, const char *ep) {
269 switch (*p) {
270 case '.': return 1; /* matches any char */
271 case L_ESC: return match_class(c, uchar(*(p+1)));
272 case '[': return matchbracketclass(c, p, ep-1);
273 default: return (uchar(*p) == c);
274 }
275}
276
277
278static const char *match (MatchState *ms, const char *s, const char *p);
279
280
281static const char *matchbalance (MatchState *ms, const char *s,
282 const char *p) {
283 if (*p == 0 || *(p+1) == 0)
284 luaL_error(ms->L, "unbalanced pattern");
285 if (*s != *p) return NULL;
286 else {
287 int b = *p;
288 int e = *(p+1);
289 int cont = 1;
290 while (++s < ms->src_end) {
291 if (*s == e) {
292 if (--cont == 0) return s+1;
293 }
294 else if (*s == b) cont++;
295 }
296 }
297 return NULL; /* string ends out of balance */
298}
299
300
301static const char *max_expand (MatchState *ms, const char *s,
302 const char *p, const char *ep) {
303 ptrdiff_t i = 0; /* counts maximum expand for item */
304 while ((s+i)<ms->src_end && singlematch(uchar(*(s+i)), p, ep))
305 i++;
306 /* keeps trying to match with the maximum repetitions */
307 while (i>=0) {
308 const char *res = match(ms, (s+i), ep+1);
309 if (res) return res;
310 i--; /* else didn't match; reduce 1 repetition to try again */
311 }
312 return NULL;
313}
314
315
316static const char *min_expand (MatchState *ms, const char *s,
317 const char *p, const char *ep) {
318 for (;;) {
319 const char *res = match(ms, s, ep+1);
320 if (res != NULL)
321 return res;
322 else if (s<ms->src_end && singlematch(uchar(*s), p, ep))
323 s++; /* try with one more repetition */
324 else return NULL;
325 }
326}
327
328
329static const char *start_capture (MatchState *ms, const char *s,
330 const char *p, int what) {
331 const char *res;
332 int level = ms->level;
333 if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");
334 ms->capture[level].init = s;
335 ms->capture[level].len = what;
336 ms->level = level+1;
337 if ((res=match(ms, s, p)) == NULL) /* match failed? */
338 ms->level--; /* undo capture */
339 return res;
340}
341
342
343static const char *end_capture (MatchState *ms, const char *s,
344 const char *p) {
345 int l = capture_to_close(ms);
346 const char *res;
347 ms->capture[l].len = s - ms->capture[l].init; /* close capture */
348 if ((res = match(ms, s, p)) == NULL) /* match failed? */
349 ms->capture[l].len = CAP_UNFINISHED; /* undo capture */
350 return res;
351}
352
353
354static const char *match_capture (MatchState *ms, const char *s, int l) {
355 size_t len;
356 l = check_capture(ms, l);
357 len = ms->capture[l].len;
358 if ((size_t)(ms->src_end-s) >= len &&
359 memcmp(ms->capture[l].init, s, len) == 0)
360 return s+len;
361 else return NULL;
362}
363
364
365static const char *match (MatchState *ms, const char *s, const char *p) {
366 init: /* using goto's to optimize tail recursion */
367 switch (*p) {
368 case '(': { /* start capture */
369 if (*(p+1) == ')') /* position capture? */
370 return start_capture(ms, s, p+2, CAP_POSITION);
371 else
372 return start_capture(ms, s, p+1, CAP_UNFINISHED);
373 }
374 case ')': { /* end capture */
375 return end_capture(ms, s, p+1);
376 }
377 case L_ESC: {
378 switch (*(p+1)) {
379 case 'b': { /* balanced string? */
380 s = matchbalance(ms, s, p+2);
381 if (s == NULL) return NULL;
382 p+=4; goto init; /* else return match(ms, s, p+4); */
383 }
384 case 'f': { /* frontier? */
385 const char *ep; char previous;
386 p += 2;
387 if (*p != '[')
388 luaL_error(ms->L, "missing " LUA_QL("[") " after "
389 LUA_QL("%%f") " in pattern");
390 ep = classend(ms, p); /* points to what is next */
391 previous = (s == ms->src_init) ? '\0' : *(s-1);
392 if (matchbracketclass(uchar(previous), p, ep-1) ||
393 !matchbracketclass(uchar(*s), p, ep-1)) return NULL;
394 p=ep; goto init; /* else return match(ms, s, ep); */
395 }
396 default: {
397 if (isdigit(uchar(*(p+1)))) { /* capture results (%0-%9)? */
398 s = match_capture(ms, s, uchar(*(p+1)));
399 if (s == NULL) return NULL;
400 p+=2; goto init; /* else return match(ms, s, p+2) */
401 }
402 goto dflt; /* case default */
403 }
404 }
405 }
406 case '\0': { /* end of pattern */
407 return s; /* match succeeded */
408 }
409 case '$': {
410 if (*(p+1) == '\0') /* is the `$' the last char in pattern? */
411 return (s == ms->src_end) ? s : NULL; /* check end of string */
412 else goto dflt;
413 }
414 default: dflt: { /* it is a pattern item */
415 const char *ep = classend(ms, p); /* points to what is next */
416 int m = s<ms->src_end && singlematch(uchar(*s), p, ep);
417 switch (*ep) {
418 case '?': { /* optional */
419 const char *res;
420 if (m && ((res=match(ms, s+1, ep+1)) != NULL))
421 return res;
422 p=ep+1; goto init; /* else return match(ms, s, ep+1); */
423 }
424 case '*': { /* 0 or more repetitions */
425 return max_expand(ms, s, p, ep);
426 }
427 case '+': { /* 1 or more repetitions */
428 return (m ? max_expand(ms, s+1, p, ep) : NULL);
429 }
430 case '-': { /* 0 or more repetitions (minimum) */
431 return min_expand(ms, s, p, ep);
432 }
433 default: {
434 if (!m) return NULL;
435 s++; p=ep; goto init; /* else return match(ms, s+1, ep); */
436 }
437 }
438 }
439 }
440}
441
442
443
444static const char *lmemfind (const char *s1, size_t l1,
445 const char *s2, size_t l2) {
446 if (l2 == 0) return s1; /* empty strings are everywhere */
447 else if (l2 > l1) return NULL; /* avoids a negative `l1' */
448 else {
449 const char *init; /* to search for a `*s2' inside `s1' */
450 l2--; /* 1st char will be checked by `memchr' */
451 l1 = l1-l2; /* `s2' cannot be found after that */
452 while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {
453 init++; /* 1st char is already checked */
454 if (memcmp(init, s2+1, l2) == 0)
455 return init-1;
456 else { /* correct `l1' and `s1' to try again */
457 l1 -= init-s1;
458 s1 = init;
459 }
460 }
461 return NULL; /* not found */
462 }
463}
464
465
466static void push_onecapture (MatchState *ms, int i, const char *s,
467 const char *e) {
468 if (i >= ms->level) {
469 if (i == 0) /* ms->level == 0, too */
470 lua_pushlstring(ms->L, s, e - s); /* add whole match */
471 else
472 luaL_error(ms->L, "invalid capture index");
473 }
474 else {
475 ptrdiff_t l = ms->capture[i].len;
476 if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
477 if (l == CAP_POSITION)
478 lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1);
479 else
480 lua_pushlstring(ms->L, ms->capture[i].init, l);
481 }
482}
483
484
485static int push_captures (MatchState *ms, const char *s, const char *e) {
486 int i;
487 int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
488 luaL_checkstack(ms->L, nlevels, "too many captures");
489 for (i = 0; i < nlevels; i++)
490 push_onecapture(ms, i, s, e);
491 return nlevels; /* number of strings pushed */
492}
493
494
495static int str_find_aux (lua_State *L, int find) {
496 size_t l1, l2;
497 const char *s = luaL_checklstring(L, 1, &l1);
498 const char *p = luaL_checklstring(L, 2, &l2);
499 ptrdiff_t init = posrelat(luaL_optinteger(L, 3, 1), l1) - 1;
500 if (init < 0) init = 0;
501 else if ((size_t)(init) > l1) init = (ptrdiff_t)l1;
502 if (find && (lua_toboolean(L, 4) || /* explicit request? */
503 strpbrk(p, SPECIALS) == NULL)) { /* or no special characters? */
504 /* do a plain search */
505 const char *s2 = lmemfind(s+init, l1-init, p, l2);
506 if (s2) {
507 lua_pushinteger(L, s2-s+1);
508 lua_pushinteger(L, s2-s+l2);
509 return 2;
510 }
511 }
512 else {
513 MatchState ms;
514 int anchor = (*p == '^') ? (p++, 1) : 0;
515 const char *s1=s+init;
516 ms.L = L;
517 ms.src_init = s;
518 ms.src_end = s+l1;
519 do {
520 const char *res;
521 ms.level = 0;
522 if ((res=match(&ms, s1, p)) != NULL) {
523 if (find) {
524 lua_pushinteger(L, s1-s+1); /* start */
525 lua_pushinteger(L, res-s); /* end */
526 return push_captures(&ms, NULL, 0) + 2;
527 }
528 else
529 return push_captures(&ms, s1, res);
530 }
531 } while (s1++ < ms.src_end && !anchor);
532 }
533 lua_pushnil(L); /* not found */
534 return 1;
535}
536
537
538static int str_find (lua_State *L) {
539 return str_find_aux(L, 1);
540}
541
542
543static int str_match (lua_State *L) {
544 return str_find_aux(L, 0);
545}
546
547
548static int gmatch_aux (lua_State *L) {
549 MatchState ms;
550 size_t ls;
551 const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls);
552 const char *p = lua_tostring(L, lua_upvalueindex(2));
553 const char *src;
554 ms.L = L;
555 ms.src_init = s;
556 ms.src_end = s+ls;
557 for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3));
558 src <= ms.src_end;
559 src++) {
560 const char *e;
561 ms.level = 0;
562 if ((e = match(&ms, src, p)) != NULL) {
563 lua_Integer newstart = e-s;
564 if (e == src) newstart++; /* empty match? go at least one position */
565 lua_pushinteger(L, newstart);
566 lua_replace(L, lua_upvalueindex(3));
567 return push_captures(&ms, src, e);
568 }
569 }
570 return 0; /* not found */
571}
572
573
574static int gmatch (lua_State *L) {
575 luaL_checkstring(L, 1);
576 luaL_checkstring(L, 2);
577 lua_settop(L, 2);
578 lua_pushinteger(L, 0);
579 lua_pushcclosure(L, gmatch_aux, 3);
580 return 1;
581}
582
583
584static int gfind_nodef (lua_State *L) {
585 return luaL_error(L, LUA_QL("string.gfind") " was renamed to "
586 LUA_QL("string.gmatch"));
587}
588
589
590static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
591 const char *e) {
592 size_t l, i;
593 const char *news = lua_tolstring(ms->L, 3, &l);
594 for (i = 0; i < l; i++) {
595 if (news[i] != L_ESC)
596 luaL_addchar(b, news[i]);
597 else {
598 i++; /* skip ESC */
599 if (!isdigit(uchar(news[i])))
600 luaL_addchar(b, news[i]);
601 else if (news[i] == '0')
602 luaL_addlstring(b, s, e - s);
603 else {
604 push_onecapture(ms, news[i] - '1', s, e);
605 luaL_addvalue(b); /* add capture to accumulated result */
606 }
607 }
608 }
609}
610
611
612static void add_value (MatchState *ms, luaL_Buffer *b, const char *s,
613 const char *e) {
614 lua_State *L = ms->L;
615 switch (lua_type(L, 3)) {
616 case LUA_TNUMBER:
617 case LUA_TSTRING: {
618 add_s(ms, b, s, e);
619 return;
620 }
621 case LUA_TFUNCTION: {
622 int n;
623 lua_pushvalue(L, 3);
624 n = push_captures(ms, s, e);
625 lua_call(L, n, 1);
626 break;
627 }
628 case LUA_TTABLE: {
629 push_onecapture(ms, 0, s, e);
630 lua_gettable(L, 3);
631 break;
632 }
633 }
634 if (!lua_toboolean(L, -1)) { /* nil or false? */
635 lua_pop(L, 1);
636 lua_pushlstring(L, s, e - s); /* keep original text */
637 }
638 else if (!lua_isstring(L, -1))
639 luaL_error(L, "invalid replacement value (a %s)", luaL_typename(L, -1));
640 luaL_addvalue(b); /* add result to accumulator */
641}
642
643
644static int str_gsub (lua_State *L) {
645 size_t srcl;
646 const char *src = luaL_checklstring(L, 1, &srcl);
647 const char *p = luaL_checkstring(L, 2);
648 int tr = lua_type(L, 3);
649 int max_s = luaL_optint(L, 4, srcl+1);
650 int anchor = (*p == '^') ? (p++, 1) : 0;
651 int n = 0;
652 MatchState ms;
653 luaL_Buffer b;
654 luaL_argcheck(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||
655 tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3,
656 "string/function/table expected");
657 luaL_buffinit(L, &b);
658 ms.L = L;
659 ms.src_init = src;
660 ms.src_end = src+srcl;
661 while (n < max_s) {
662 const char *e;
663 ms.level = 0;
664 e = match(&ms, src, p);
665 if (e) {
666 n++;
667 add_value(&ms, &b, src, e);
668 }
669 if (e && e>src) /* non empty match? */
670 src = e; /* skip it */
671 else if (src < ms.src_end)
672 luaL_addchar(&b, *src++);
673 else break;
674 if (anchor) break;
675 }
676 luaL_addlstring(&b, src, ms.src_end-src);
677 luaL_pushresult(&b);
678 lua_pushinteger(L, n); /* number of substitutions */
679 return 2;
680}
681
682/* }====================================================== */
683
684
685/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */
686#define MAX_ITEM 512
687/* valid flags in a format specification */
688#define FLAGS "-+ #0"
689/*
690** maximum size of each format specification (such as '%-099.99d')
691** (+10 accounts for %99.99x plus margin of error)
692*/
693#define MAX_FORMAT (sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10)
694
695
696static void addquoted (lua_State *L, luaL_Buffer *b, int arg) {
697 size_t l;
698 const char *s = luaL_checklstring(L, arg, &l);
699 luaL_addchar(b, '"');
700 while (l--) {
701 switch (*s) {
702 case '"': case '\\': case '\n': {
703 luaL_addchar(b, '\\');
704 luaL_addchar(b, *s);
705 break;
706 }
707 case '\r': {
708 luaL_addlstring(b, "\\r", 2);
709 break;
710 }
711 case '\0': {
712 luaL_addlstring(b, "\\000", 4);
713 break;
714 }
715 default: {
716 luaL_addchar(b, *s);
717 break;
718 }
719 }
720 s++;
721 }
722 luaL_addchar(b, '"');
723}
724
725static const char *scanformat (lua_State *L, const char *strfrmt, char *form) {
726 const char *p = strfrmt;
727 while (*p != '\0' && strchr(FLAGS, *p) != NULL) p++; /* skip flags */
728 if ((size_t)(p - strfrmt) >= sizeof(FLAGS))
729 luaL_error(L, "invalid format (repeated flags)");
730 if (isdigit(uchar(*p))) p++; /* skip width */
731 if (isdigit(uchar(*p))) p++; /* (2 digits at most) */
732 if (*p == '.') {
733 p++;
734 if (isdigit(uchar(*p))) p++; /* skip precision */
735 if (isdigit(uchar(*p))) p++; /* (2 digits at most) */
736 }
737 if (isdigit(uchar(*p)))
738 luaL_error(L, "invalid format (width or precision too long)");
739 *(form++) = '%';
740 strncpy(form, strfrmt, p - strfrmt + 1);
741 form += p - strfrmt + 1;
742 *form = '\0';
743 return p;
744}
745
746
747static void addintlen (char *form) {
748 size_t l = strlen(form);
749 char spec = form[l - 1];
750 strcpy(form + l - 1, LUA_INTFRMLEN);
751 form[l + sizeof(LUA_INTFRMLEN) - 2] = spec;
752 form[l + sizeof(LUA_INTFRMLEN) - 1] = '\0';
753}
754
755
756static int str_format (lua_State *L) {
757 int top = lua_gettop(L);
758 int arg = 1;
759 size_t sfl;
760 const char *strfrmt = luaL_checklstring(L, arg, &sfl);
761 const char *strfrmt_end = strfrmt+sfl;
762 luaL_Buffer b;
763 luaL_buffinit(L, &b);
764 while (strfrmt < strfrmt_end) {
765 if (*strfrmt != L_ESC)
766 luaL_addchar(&b, *strfrmt++);
767 else if (*++strfrmt == L_ESC)
768 luaL_addchar(&b, *strfrmt++); /* %% */
769 else { /* format item */
770 char form[MAX_FORMAT]; /* to store the format (`%...') */
771 char buff[MAX_ITEM]; /* to store the formatted item */
772 if (++arg > top)
773 luaL_argerror(L, arg, "no value");
774 strfrmt = scanformat(L, strfrmt, form);
775 switch (*strfrmt++) {
776 case 'c': {
777 sprintf(buff, form, (int)luaL_checknumber(L, arg));
778 break;
779 }
780 case 'd': case 'i': {
781 addintlen(form);
782 sprintf(buff, form, (LUA_INTFRM_T)luaL_checknumber(L, arg));
783 break;
784 }
785 case 'o': case 'u': case 'x': case 'X': {
786 addintlen(form);
787 sprintf(buff, form, (unsigned LUA_INTFRM_T)luaL_checknumber(L, arg));
788 break;
789 }
790 case 'e': case 'E': case 'f':
791 case 'g': case 'G': {
792 sprintf(buff, form, (double)luaL_checknumber(L, arg));
793 break;
794 }
795 case 'q': {
796 addquoted(L, &b, arg);
797 continue; /* skip the 'addsize' at the end */
798 }
799 case 's': {
800 size_t l;
801 const char *s = luaL_checklstring(L, arg, &l);
802 if (!strchr(form, '.') && l >= 100) {
803 /* no precision and string is too long to be formatted;
804 keep original string */
805 lua_pushvalue(L, arg);
806 luaL_addvalue(&b);
807 continue; /* skip the `addsize' at the end */
808 }
809 else {
810 sprintf(buff, form, s);
811 break;
812 }
813 }
814 default: { /* also treat cases `pnLlh' */
815 return luaL_error(L, "invalid option " LUA_QL("%%%c") " to "
816 LUA_QL("format"), *(strfrmt - 1));
817 }
818 }
819 luaL_addlstring(&b, buff, strlen(buff));
820 }
821 }
822 luaL_pushresult(&b);
823 return 1;
824}
825
826
827static const luaL_Reg strlib[] = {
828 {"byte", str_byte},
829 {"char", str_char},
830 {"dump", str_dump},
831 {"find", str_find},
832 {"format", str_format},
833 {"gfind", gfind_nodef},
834 {"gmatch", gmatch},
835 {"gsub", str_gsub},
836 {"len", str_len},
837 {"lower", str_lower},
838 {"match", str_match},
839 {"rep", str_rep},
840 {"reverse", str_reverse},
841 {"sub", str_sub},
842 {"upper", str_upper},
843 {NULL, NULL}
844};
845
846
847static void createmetatable (lua_State *L) {
848 lua_createtable(L, 0, 1); /* create metatable for strings */
849 lua_pushliteral(L, ""); /* dummy string */
850 lua_pushvalue(L, -2);
851 lua_setmetatable(L, -2); /* set string metatable */
852 lua_pop(L, 1); /* pop dummy string */
853 lua_pushvalue(L, -2); /* string library... */
854 lua_setfield(L, -2, "__index"); /* ...is the __index metamethod */
855 lua_pop(L, 1); /* pop metatable */
856}
857
858
859/*
860** Open string library
861*/
862LUALIB_API int luaopen_string (lua_State *L) {
863 luaL_register(L, LUA_STRLIBNAME, strlib);
864#if defined(LUA_COMPAT_GFIND)
865 lua_getfield(L, -1, "gmatch");
866 lua_setfield(L, -2, "gfind");
867#endif
868 createmetatable(L);
869 return 1;
870}
871
diff --git a/libraries/LuaJIT-1.1.7/src/ltable.c b/libraries/LuaJIT-1.1.7/src/ltable.c
new file mode 100644
index 0000000..6b226ad
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ltable.c
@@ -0,0 +1,588 @@
1/*
2** $Id: ltable.c,v 2.32.1.2 2007/12/28 15:32:23 roberto Exp $
3** Lua tables (hash)
4** See Copyright Notice in lua.h
5*/
6
7
8/*
9** Implementation of tables (aka arrays, objects, or hash tables).
10** Tables keep its elements in two parts: an array part and a hash part.
11** Non-negative integer keys are all candidates to be kept in the array
12** part. The actual size of the array is the largest `n' such that at
13** least half the slots between 0 and n are in use.
14** Hash uses a mix of chained scatter table with Brent's variation.
15** A main invariant of these tables is that, if an element is not
16** in its main position (i.e. the `original' position that its hash gives
17** to it), then the colliding element is in its own main position.
18** Hence even when the load factor reaches 100%, performance remains good.
19*/
20
21#include <math.h>
22#include <string.h>
23
24#define ltable_c
25#define LUA_CORE
26
27#include "lua.h"
28
29#include "ldebug.h"
30#include "ldo.h"
31#include "lgc.h"
32#include "lmem.h"
33#include "lobject.h"
34#include "lstate.h"
35#include "ltable.h"
36
37
38/*
39** max size of array part is 2^MAXBITS
40*/
41#if LUAI_BITSINT > 26
42#define MAXBITS 26
43#else
44#define MAXBITS (LUAI_BITSINT-2)
45#endif
46
47#define MAXASIZE (1 << MAXBITS)
48
49
50#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t))))
51
52#define hashstr(t,str) hashpow2(t, (str)->tsv.hash)
53#define hashboolean(t,p) hashpow2(t, p)
54
55
56/*
57** for some types, it is better to avoid modulus by power of 2, as
58** they tend to have many 2 factors.
59*/
60#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1))))
61
62
63#define hashpointer(t,p) hashmod(t, IntPoint(p))
64
65
66/*
67** number of ints inside a lua_Number
68*/
69#define numints cast_int(sizeof(lua_Number)/sizeof(int))
70
71
72
73#define dummynode (&dummynode_)
74
75static const Node dummynode_ = {
76 {{NULL}, LUA_TNIL}, /* value */
77 {{{NULL}, LUA_TNIL, NULL}} /* key */
78};
79
80
81/*
82** hash for lua_Numbers
83*/
84static Node *hashnum (const Table *t, lua_Number n) {
85 unsigned int a[numints];
86 int i;
87 if (luai_numeq(n, 0)) /* avoid problems with -0 */
88 return gnode(t, 0);
89 memcpy(a, &n, sizeof(a));
90 for (i = 1; i < numints; i++) a[0] += a[i];
91 return hashmod(t, a[0]);
92}
93
94
95
96/*
97** returns the `main' position of an element in a table (that is, the index
98** of its hash value)
99*/
100static Node *mainposition (const Table *t, const TValue *key) {
101 switch (ttype(key)) {
102 case LUA_TNUMBER:
103 return hashnum(t, nvalue(key));
104 case LUA_TSTRING:
105 return hashstr(t, rawtsvalue(key));
106 case LUA_TBOOLEAN:
107 return hashboolean(t, bvalue(key));
108 case LUA_TLIGHTUSERDATA:
109 return hashpointer(t, pvalue(key));
110 default:
111 return hashpointer(t, gcvalue(key));
112 }
113}
114
115
116/*
117** returns the index for `key' if `key' is an appropriate key to live in
118** the array part of the table, -1 otherwise.
119*/
120static int arrayindex (const TValue *key) {
121 if (ttisnumber(key)) {
122 lua_Number n = nvalue(key);
123 int k;
124 lua_number2int(k, n);
125 if (luai_numeq(cast_num(k), n))
126 return k;
127 }
128 return -1; /* `key' did not match some condition */
129}
130
131
132/*
133** returns the index of a `key' for table traversals. First goes all
134** elements in the array part, then elements in the hash part. The
135** beginning of a traversal is signalled by -1.
136*/
137static int findindex (lua_State *L, Table *t, StkId key) {
138 int i;
139 if (ttisnil(key)) return -1; /* first iteration */
140 i = arrayindex(key);
141 if (0 < i && i <= t->sizearray) /* is `key' inside array part? */
142 return i-1; /* yes; that's the index (corrected to C) */
143 else {
144 Node *n = mainposition(t, key);
145 do { /* check whether `key' is somewhere in the chain */
146 /* key may be dead already, but it is ok to use it in `next' */
147 if (luaO_rawequalObj(key2tval(n), key) ||
148 (ttype(gkey(n)) == LUA_TDEADKEY && iscollectable(key) &&
149 gcvalue(gkey(n)) == gcvalue(key))) {
150 i = cast_int(n - gnode(t, 0)); /* key index in hash table */
151 /* hash elements are numbered after array ones */
152 return i + t->sizearray;
153 }
154 else n = gnext(n);
155 } while (n);
156 luaG_runerror(L, "invalid key to " LUA_QL("next")); /* key not found */
157 return 0; /* to avoid warnings */
158 }
159}
160
161
162int luaH_next (lua_State *L, Table *t, StkId key) {
163 int i = findindex(L, t, key); /* find original element */
164 for (i++; i < t->sizearray; i++) { /* try first array part */
165 if (!ttisnil(&t->array[i])) { /* a non-nil value? */
166 setnvalue(key, cast_num(i+1));
167 setobj2s(L, key+1, &t->array[i]);
168 return 1;
169 }
170 }
171 for (i -= t->sizearray; i < sizenode(t); i++) { /* then hash part */
172 if (!ttisnil(gval(gnode(t, i)))) { /* a non-nil value? */
173 setobj2s(L, key, key2tval(gnode(t, i)));
174 setobj2s(L, key+1, gval(gnode(t, i)));
175 return 1;
176 }
177 }
178 return 0; /* no more elements */
179}
180
181
182/*
183** {=============================================================
184** Rehash
185** ==============================================================
186*/
187
188
189static int computesizes (int nums[], int *narray) {
190 int i;
191 int twotoi; /* 2^i */
192 int a = 0; /* number of elements smaller than 2^i */
193 int na = 0; /* number of elements to go to array part */
194 int n = 0; /* optimal size for array part */
195 for (i = 0, twotoi = 1; twotoi/2 < *narray; i++, twotoi *= 2) {
196 if (nums[i] > 0) {
197 a += nums[i];
198 if (a > twotoi/2) { /* more than half elements present? */
199 n = twotoi; /* optimal size (till now) */
200 na = a; /* all elements smaller than n will go to array part */
201 }
202 }
203 if (a == *narray) break; /* all elements already counted */
204 }
205 *narray = n;
206 lua_assert(*narray/2 <= na && na <= *narray);
207 return na;
208}
209
210
211static int countint (const TValue *key, int *nums) {
212 int k = arrayindex(key);
213 if (0 < k && k <= MAXASIZE) { /* is `key' an appropriate array index? */
214 nums[ceillog2(k)]++; /* count as such */
215 return 1;
216 }
217 else
218 return 0;
219}
220
221
222static int numusearray (const Table *t, int *nums) {
223 int lg;
224 int ttlg; /* 2^lg */
225 int ause = 0; /* summation of `nums' */
226 int i = 1; /* count to traverse all array keys */
227 for (lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg*=2) { /* for each slice */
228 int lc = 0; /* counter */
229 int lim = ttlg;
230 if (lim > t->sizearray) {
231 lim = t->sizearray; /* adjust upper limit */
232 if (i > lim)
233 break; /* no more elements to count */
234 }
235 /* count elements in range (2^(lg-1), 2^lg] */
236 for (; i <= lim; i++) {
237 if (!ttisnil(&t->array[i-1]))
238 lc++;
239 }
240 nums[lg] += lc;
241 ause += lc;
242 }
243 return ause;
244}
245
246
247static int numusehash (const Table *t, int *nums, int *pnasize) {
248 int totaluse = 0; /* total number of elements */
249 int ause = 0; /* summation of `nums' */
250 int i = sizenode(t);
251 while (i--) {
252 Node *n = &t->node[i];
253 if (!ttisnil(gval(n))) {
254 ause += countint(key2tval(n), nums);
255 totaluse++;
256 }
257 }
258 *pnasize += ause;
259 return totaluse;
260}
261
262
263static void setarrayvector (lua_State *L, Table *t, int size) {
264 int i;
265 luaM_reallocvector(L, t->array, t->sizearray, size, TValue);
266 for (i=t->sizearray; i<size; i++)
267 setnilvalue(&t->array[i]);
268 t->sizearray = size;
269}
270
271
272static void setnodevector (lua_State *L, Table *t, int size) {
273 int lsize;
274 if (size == 0) { /* no elements to hash part? */
275 t->node = cast(Node *, dummynode); /* use common `dummynode' */
276 lsize = 0;
277 }
278 else {
279 int i;
280 lsize = ceillog2(size);
281 if (lsize > MAXBITS)
282 luaG_runerror(L, "table overflow");
283 size = twoto(lsize);
284 t->node = luaM_newvector(L, size, Node);
285 for (i=0; i<size; i++) {
286 Node *n = gnode(t, i);
287 gnext(n) = NULL;
288 setnilvalue(gkey(n));
289 setnilvalue(gval(n));
290 }
291 }
292 t->lsizenode = cast_byte(lsize);
293 t->lastfree = gnode(t, size); /* all positions are free */
294}
295
296
297static void resize (lua_State *L, Table *t, int nasize, int nhsize) {
298 int i;
299 int oldasize = t->sizearray;
300 int oldhsize = t->lsizenode;
301 Node *nold = t->node; /* save old hash ... */
302 if (nasize > oldasize) /* array part must grow? */
303 setarrayvector(L, t, nasize);
304 /* create new hash part with appropriate size */
305 setnodevector(L, t, nhsize);
306 if (nasize < oldasize) { /* array part must shrink? */
307 t->sizearray = nasize;
308 /* re-insert elements from vanishing slice */
309 for (i=nasize; i<oldasize; i++) {
310 if (!ttisnil(&t->array[i]))
311 setobjt2t(L, luaH_setnum(L, t, i+1), &t->array[i]);
312 }
313 /* shrink array */
314 luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
315 }
316 /* re-insert elements from hash part */
317 for (i = twoto(oldhsize) - 1; i >= 0; i--) {
318 Node *old = nold+i;
319 if (!ttisnil(gval(old)))
320 setobjt2t(L, luaH_set(L, t, key2tval(old)), gval(old));
321 }
322 if (nold != dummynode)
323 luaM_freearray(L, nold, twoto(oldhsize), Node); /* free old array */
324}
325
326
327void luaH_resizearray (lua_State *L, Table *t, int nasize) {
328 int nsize = (t->node == dummynode) ? 0 : sizenode(t);
329 resize(L, t, nasize, nsize);
330}
331
332
333static void rehash (lua_State *L, Table *t, const TValue *ek) {
334 int nasize, na;
335 int nums[MAXBITS+1]; /* nums[i] = number of keys between 2^(i-1) and 2^i */
336 int i;
337 int totaluse;
338 for (i=0; i<=MAXBITS; i++) nums[i] = 0; /* reset counts */
339 nasize = numusearray(t, nums); /* count keys in array part */
340 totaluse = nasize; /* all those keys are integer keys */
341 totaluse += numusehash(t, nums, &nasize); /* count keys in hash part */
342 /* count extra key */
343 nasize += countint(ek, nums);
344 totaluse++;
345 /* compute new size for array part */
346 na = computesizes(nums, &nasize);
347 /* resize the table to new computed sizes */
348 resize(L, t, nasize, totaluse - na);
349}
350
351
352
353/*
354** }=============================================================
355*/
356
357
358Table *luaH_new (lua_State *L, int narray, int nhash) {
359 Table *t = luaM_new(L, Table);
360 luaC_link(L, obj2gco(t), LUA_TTABLE);
361 t->metatable = NULL;
362 t->flags = cast_byte(~0);
363 /* temporary values (kept only if some malloc fails) */
364 t->array = NULL;
365 t->sizearray = 0;
366 t->lsizenode = 0;
367 t->node = cast(Node *, dummynode);
368 setarrayvector(L, t, narray);
369 setnodevector(L, t, nhash);
370 return t;
371}
372
373
374void luaH_free (lua_State *L, Table *t) {
375 if (t->node != dummynode)
376 luaM_freearray(L, t->node, sizenode(t), Node);
377 luaM_freearray(L, t->array, t->sizearray, TValue);
378 luaM_free(L, t);
379}
380
381
382static Node *getfreepos (Table *t) {
383 while (t->lastfree-- > t->node) {
384 if (ttisnil(gkey(t->lastfree)))
385 return t->lastfree;
386 }
387 return NULL; /* could not find a free place */
388}
389
390
391
392/*
393** inserts a new key into a hash table; first, check whether key's main
394** position is free. If not, check whether colliding node is in its main
395** position or not: if it is not, move colliding node to an empty place and
396** put new key in its main position; otherwise (colliding node is in its main
397** position), new key goes to an empty position.
398*/
399TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) {
400 Node *mp = mainposition(t, key);
401 if (!ttisnil(gval(mp)) || mp == dummynode) {
402 Node *othern;
403 Node *n = getfreepos(t); /* get a free place */
404 if (n == NULL) { /* cannot find a free place? */
405 rehash(L, t, key); /* grow table */
406 return luaH_set(L, t, key); /* re-insert key into grown table */
407 }
408 lua_assert(n != dummynode);
409 othern = mainposition(t, key2tval(mp));
410 if (othern != mp) { /* is colliding node out of its main position? */
411 /* yes; move colliding node into free position */
412 while (gnext(othern) != mp) othern = gnext(othern); /* find previous */
413 gnext(othern) = n; /* redo the chain with `n' in place of `mp' */
414 *n = *mp; /* copy colliding node into free pos. (mp->next also goes) */
415 gnext(mp) = NULL; /* now `mp' is free */
416 setnilvalue(gval(mp));
417 }
418 else { /* colliding node is in its own main position */
419 /* new node will go into free position */
420 gnext(n) = gnext(mp); /* chain new position */
421 gnext(mp) = n;
422 mp = n;
423 }
424 }
425 gkey(mp)->value = key->value; gkey(mp)->tt = key->tt;
426 luaC_barriert(L, t, key);
427 lua_assert(ttisnil(gval(mp)));
428 return gval(mp);
429}
430
431
432/*
433** search function for integers
434*/
435const TValue *luaH_getnum (Table *t, int key) {
436 /* (1 <= key && key <= t->sizearray) */
437 if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray))
438 return &t->array[key-1];
439 else {
440 lua_Number nk = cast_num(key);
441 Node *n = hashnum(t, nk);
442 do { /* check whether `key' is somewhere in the chain */
443 if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk))
444 return gval(n); /* that's it */
445 else n = gnext(n);
446 } while (n);
447 return luaO_nilobject;
448 }
449}
450
451
452/*
453** search function for strings
454*/
455const TValue *luaH_getstr (Table *t, TString *key) {
456 Node *n = hashstr(t, key);
457 do { /* check whether `key' is somewhere in the chain */
458 if (ttisstring(gkey(n)) && rawtsvalue(gkey(n)) == key)
459 return gval(n); /* that's it */
460 else n = gnext(n);
461 } while (n);
462 return luaO_nilobject;
463}
464
465
466/*
467** main search function
468*/
469const TValue *luaH_get (Table *t, const TValue *key) {
470 switch (ttype(key)) {
471 case LUA_TNIL: return luaO_nilobject;
472 case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));
473 case LUA_TNUMBER: {
474 int k;
475 lua_Number n = nvalue(key);
476 lua_number2int(k, n);
477 if (luai_numeq(cast_num(k), nvalue(key))) /* index is int? */
478 return luaH_getnum(t, k); /* use specialized version */
479 /* else go through */
480 }
481 default: {
482 Node *n = mainposition(t, key);
483 do { /* check whether `key' is somewhere in the chain */
484 if (luaO_rawequalObj(key2tval(n), key))
485 return gval(n); /* that's it */
486 else n = gnext(n);
487 } while (n);
488 return luaO_nilobject;
489 }
490 }
491}
492
493
494TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
495 const TValue *p = luaH_get(t, key);
496 t->flags = 0;
497 if (p != luaO_nilobject)
498 return cast(TValue *, p);
499 else {
500 if (ttisnil(key)) luaG_runerror(L, "table index is nil");
501 else if (ttisnumber(key) && luai_numisnan(nvalue(key)))
502 luaG_runerror(L, "table index is NaN");
503 return luaH_newkey(L, t, key);
504 }
505}
506
507
508TValue *luaH_setnum (lua_State *L, Table *t, int key) {
509 const TValue *p = luaH_getnum(t, key);
510 if (p != luaO_nilobject)
511 return cast(TValue *, p);
512 else {
513 TValue k;
514 setnvalue(&k, cast_num(key));
515 return luaH_newkey(L, t, &k);
516 }
517}
518
519
520TValue *luaH_setstr (lua_State *L, Table *t, TString *key) {
521 const TValue *p = luaH_getstr(t, key);
522 if (p != luaO_nilobject)
523 return cast(TValue *, p);
524 else {
525 TValue k;
526 setsvalue(L, &k, key);
527 return luaH_newkey(L, t, &k);
528 }
529}
530
531
532static int unbound_search (Table *t, unsigned int j) {
533 unsigned int i = j; /* i is zero or a present index */
534 j++;
535 /* find `i' and `j' such that i is present and j is not */
536 while (!ttisnil(luaH_getnum(t, j))) {
537 i = j;
538 j *= 2;
539 if (j > cast(unsigned int, MAX_INT)) { /* overflow? */
540 /* table was built with bad purposes: resort to linear search */
541 i = 1;
542 while (!ttisnil(luaH_getnum(t, i))) i++;
543 return i - 1;
544 }
545 }
546 /* now do a binary search between them */
547 while (j - i > 1) {
548 unsigned int m = (i+j)/2;
549 if (ttisnil(luaH_getnum(t, m))) j = m;
550 else i = m;
551 }
552 return i;
553}
554
555
556/*
557** Try to find a boundary in table `t'. A `boundary' is an integer index
558** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil).
559*/
560int luaH_getn (Table *t) {
561 unsigned int j = t->sizearray;
562 if (j > 0 && ttisnil(&t->array[j - 1])) {
563 /* there is a boundary in the array part: (binary) search for it */
564 unsigned int i = 0;
565 while (j - i > 1) {
566 unsigned int m = (i+j)/2;
567 if (ttisnil(&t->array[m - 1])) j = m;
568 else i = m;
569 }
570 return i;
571 }
572 /* else must find a boundary in hash part */
573 else if (t->node == dummynode) /* hash part is empty? */
574 return j; /* that is easy... */
575 else return unbound_search(t, j);
576}
577
578
579
580#if defined(LUA_DEBUG)
581
582Node *luaH_mainposition (const Table *t, const TValue *key) {
583 return mainposition(t, key);
584}
585
586int luaH_isdummy (Node *n) { return n == dummynode; }
587
588#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ltable.h b/libraries/LuaJIT-1.1.7/src/ltable.h
new file mode 100644
index 0000000..a61c981
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ltable.h
@@ -0,0 +1,41 @@
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
21LUAI_FUNC const TValue *luaH_getnum (Table *t, int key);
22LUAI_FUNC TValue *luaH_setnum (lua_State *L, Table *t, int key);
23LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
24LUAI_FUNC TValue *luaH_setstr (lua_State *L, Table *t, TString *key);
25LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
26LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key);
27LUAI_FUNC Table *luaH_new (lua_State *L, int narray, int lnhash);
28LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize);
29LUAI_FUNC void luaH_free (lua_State *L, Table *t);
30LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
31LUAI_FUNC int luaH_getn (Table *t);
32LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key);
33
34
35#if defined(LUA_DEBUG)
36LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
37LUAI_FUNC int luaH_isdummy (Node *n);
38#endif
39
40
41#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ltablib.c b/libraries/LuaJIT-1.1.7/src/ltablib.c
new file mode 100644
index 0000000..b6d9cb4
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ltablib.c
@@ -0,0 +1,287 @@
1/*
2** $Id: ltablib.c,v 1.38.1.3 2008/02/14 16:46:58 roberto Exp $
3** Library for Table Manipulation
4** See Copyright Notice in lua.h
5*/
6
7
8#include <stddef.h>
9
10#define ltablib_c
11#define LUA_LIB
12
13#include "lua.h"
14
15#include "lauxlib.h"
16#include "lualib.h"
17
18
19#define aux_getn(L,n) (luaL_checktype(L, n, LUA_TTABLE), luaL_getn(L, n))
20
21
22static int foreachi (lua_State *L) {
23 int i;
24 int n = aux_getn(L, 1);
25 luaL_checktype(L, 2, LUA_TFUNCTION);
26 for (i=1; i <= n; i++) {
27 lua_pushvalue(L, 2); /* function */
28 lua_pushinteger(L, i); /* 1st argument */
29 lua_rawgeti(L, 1, i); /* 2nd argument */
30 lua_call(L, 2, 1);
31 if (!lua_isnil(L, -1))
32 return 1;
33 lua_pop(L, 1); /* remove nil result */
34 }
35 return 0;
36}
37
38
39static int foreach (lua_State *L) {
40 luaL_checktype(L, 1, LUA_TTABLE);
41 luaL_checktype(L, 2, LUA_TFUNCTION);
42 lua_pushnil(L); /* first key */
43 while (lua_next(L, 1)) {
44 lua_pushvalue(L, 2); /* function */
45 lua_pushvalue(L, -3); /* key */
46 lua_pushvalue(L, -3); /* value */
47 lua_call(L, 2, 1);
48 if (!lua_isnil(L, -1))
49 return 1;
50 lua_pop(L, 2); /* remove value and result */
51 }
52 return 0;
53}
54
55
56static int maxn (lua_State *L) {
57 lua_Number max = 0;
58 luaL_checktype(L, 1, LUA_TTABLE);
59 lua_pushnil(L); /* first key */
60 while (lua_next(L, 1)) {
61 lua_pop(L, 1); /* remove value */
62 if (lua_type(L, -1) == LUA_TNUMBER) {
63 lua_Number v = lua_tonumber(L, -1);
64 if (v > max) max = v;
65 }
66 }
67 lua_pushnumber(L, max);
68 return 1;
69}
70
71
72static int getn (lua_State *L) {
73 lua_pushinteger(L, aux_getn(L, 1));
74 return 1;
75}
76
77
78static int setn (lua_State *L) {
79 luaL_checktype(L, 1, LUA_TTABLE);
80#ifndef luaL_setn
81 luaL_setn(L, 1, luaL_checkint(L, 2));
82#else
83 luaL_error(L, LUA_QL("setn") " is obsolete");
84#endif
85 lua_pushvalue(L, 1);
86 return 1;
87}
88
89
90static int tinsert (lua_State *L) {
91 int e = aux_getn(L, 1) + 1; /* first empty element */
92 int pos; /* where to insert new element */
93 switch (lua_gettop(L)) {
94 case 2: { /* called with only 2 arguments */
95 pos = e; /* insert new element at the end */
96 break;
97 }
98 case 3: {
99 int i;
100 pos = luaL_checkint(L, 2); /* 2nd argument is the position */
101 if (pos > e) e = pos; /* `grow' array if necessary */
102 for (i = e; i > pos; i--) { /* move up elements */
103 lua_rawgeti(L, 1, i-1);
104 lua_rawseti(L, 1, i); /* t[i] = t[i-1] */
105 }
106 break;
107 }
108 default: {
109 return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
110 }
111 }
112 luaL_setn(L, 1, e); /* new size */
113 lua_rawseti(L, 1, pos); /* t[pos] = v */
114 return 0;
115}
116
117
118static int tremove (lua_State *L) {
119 int e = aux_getn(L, 1);
120 int pos = luaL_optint(L, 2, e);
121 if (!(1 <= pos && pos <= e)) /* position is outside bounds? */
122 return 0; /* nothing to remove */
123 luaL_setn(L, 1, e - 1); /* t.n = n-1 */
124 lua_rawgeti(L, 1, pos); /* result = t[pos] */
125 for ( ;pos<e; pos++) {
126 lua_rawgeti(L, 1, pos+1);
127 lua_rawseti(L, 1, pos); /* t[pos] = t[pos+1] */
128 }
129 lua_pushnil(L);
130 lua_rawseti(L, 1, e); /* t[e] = nil */
131 return 1;
132}
133
134
135static void addfield (lua_State *L, luaL_Buffer *b, int i) {
136 lua_rawgeti(L, 1, i);
137 if (!lua_isstring(L, -1))
138 luaL_error(L, "invalid value (%s) at index %d in table for "
139 LUA_QL("concat"), luaL_typename(L, -1), i);
140 luaL_addvalue(b);
141}
142
143
144static int tconcat (lua_State *L) {
145 luaL_Buffer b;
146 size_t lsep;
147 int i, last;
148 const char *sep = luaL_optlstring(L, 2, "", &lsep);
149 luaL_checktype(L, 1, LUA_TTABLE);
150 i = luaL_optint(L, 3, 1);
151 last = luaL_opt(L, luaL_checkint, 4, luaL_getn(L, 1));
152 luaL_buffinit(L, &b);
153 for (; i < last; i++) {
154 addfield(L, &b, i);
155 luaL_addlstring(&b, sep, lsep);
156 }
157 if (i == last) /* add last value (if interval was not empty) */
158 addfield(L, &b, i);
159 luaL_pushresult(&b);
160 return 1;
161}
162
163
164
165/*
166** {======================================================
167** Quicksort
168** (based on `Algorithms in MODULA-3', Robert Sedgewick;
169** Addison-Wesley, 1993.)
170*/
171
172
173static void set2 (lua_State *L, int i, int j) {
174 lua_rawseti(L, 1, i);
175 lua_rawseti(L, 1, j);
176}
177
178static int sort_comp (lua_State *L, int a, int b) {
179 if (!lua_isnil(L, 2)) { /* function? */
180 int res;
181 lua_pushvalue(L, 2);
182 lua_pushvalue(L, a-1); /* -1 to compensate function */
183 lua_pushvalue(L, b-2); /* -2 to compensate function and `a' */
184 lua_call(L, 2, 1);
185 res = lua_toboolean(L, -1);
186 lua_pop(L, 1);
187 return res;
188 }
189 else /* a < b? */
190 return lua_lessthan(L, a, b);
191}
192
193static void auxsort (lua_State *L, int l, int u) {
194 while (l < u) { /* for tail recursion */
195 int i, j;
196 /* sort elements a[l], a[(l+u)/2] and a[u] */
197 lua_rawgeti(L, 1, l);
198 lua_rawgeti(L, 1, u);
199 if (sort_comp(L, -1, -2)) /* a[u] < a[l]? */
200 set2(L, l, u); /* swap a[l] - a[u] */
201 else
202 lua_pop(L, 2);
203 if (u-l == 1) break; /* only 2 elements */
204 i = (l+u)/2;
205 lua_rawgeti(L, 1, i);
206 lua_rawgeti(L, 1, l);
207 if (sort_comp(L, -2, -1)) /* a[i]<a[l]? */
208 set2(L, i, l);
209 else {
210 lua_pop(L, 1); /* remove a[l] */
211 lua_rawgeti(L, 1, u);
212 if (sort_comp(L, -1, -2)) /* a[u]<a[i]? */
213 set2(L, i, u);
214 else
215 lua_pop(L, 2);
216 }
217 if (u-l == 2) break; /* only 3 elements */
218 lua_rawgeti(L, 1, i); /* Pivot */
219 lua_pushvalue(L, -1);
220 lua_rawgeti(L, 1, u-1);
221 set2(L, i, u-1);
222 /* a[l] <= P == a[u-1] <= a[u], only need to sort from l+1 to u-2 */
223 i = l; j = u-1;
224 for (;;) { /* invariant: a[l..i] <= P <= a[j..u] */
225 /* repeat ++i until a[i] >= P */
226 while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) {
227 if (i>u) luaL_error(L, "invalid order function for sorting");
228 lua_pop(L, 1); /* remove a[i] */
229 }
230 /* repeat --j until a[j] <= P */
231 while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) {
232 if (j<l) luaL_error(L, "invalid order function for sorting");
233 lua_pop(L, 1); /* remove a[j] */
234 }
235 if (j<i) {
236 lua_pop(L, 3); /* pop pivot, a[i], a[j] */
237 break;
238 }
239 set2(L, i, j);
240 }
241 lua_rawgeti(L, 1, u-1);
242 lua_rawgeti(L, 1, i);
243 set2(L, u-1, i); /* swap pivot (a[u-1]) with a[i] */
244 /* a[l..i-1] <= a[i] == P <= a[i+1..u] */
245 /* adjust so that smaller half is in [j..i] and larger one in [l..u] */
246 if (i-l < u-i) {
247 j=l; i=i-1; l=i+2;
248 }
249 else {
250 j=i+1; i=u; u=j-2;
251 }
252 auxsort(L, j, i); /* call recursively the smaller one */
253 } /* repeat the routine for the larger one */
254}
255
256static int sort (lua_State *L) {
257 int n = aux_getn(L, 1);
258 luaL_checkstack(L, 40, ""); /* assume array is smaller than 2^40 */
259 if (!lua_isnoneornil(L, 2)) /* is there a 2nd argument? */
260 luaL_checktype(L, 2, LUA_TFUNCTION);
261 lua_settop(L, 2); /* make sure there is two arguments */
262 auxsort(L, 1, n);
263 return 0;
264}
265
266/* }====================================================== */
267
268
269static const luaL_Reg tab_funcs[] = {
270 {"concat", tconcat},
271 {"foreach", foreach},
272 {"foreachi", foreachi},
273 {"getn", getn},
274 {"maxn", maxn},
275 {"insert", tinsert},
276 {"remove", tremove},
277 {"setn", setn},
278 {"sort", sort},
279 {NULL, NULL}
280};
281
282
283LUALIB_API int luaopen_table (lua_State *L) {
284 luaL_register(L, LUA_TABLIBNAME, tab_funcs);
285 return 1;
286}
287
diff --git a/libraries/LuaJIT-1.1.7/src/ltm.c b/libraries/LuaJIT-1.1.7/src/ltm.c
new file mode 100644
index 0000000..c27f0f6
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ltm.c
@@ -0,0 +1,75 @@
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
23const char *const luaT_typenames[] = {
24 "nil", "boolean", "userdata", "number",
25 "string", "table", "function", "userdata", "thread",
26 "proto", "upval"
27};
28
29
30void 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*/
50const 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
61const 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
diff --git a/libraries/LuaJIT-1.1.7/src/ltm.h b/libraries/LuaJIT-1.1.7/src/ltm.h
new file mode 100644
index 0000000..64343b7
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ltm.h
@@ -0,0 +1,54 @@
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*/
18typedef 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
46LUAI_DATA const char *const luaT_typenames[];
47
48
49LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);
50LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
51 TMS event);
52LUAI_FUNC void luaT_init (lua_State *L);
53
54#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lua.c b/libraries/LuaJIT-1.1.7/src/lua.c
new file mode 100644
index 0000000..a4b413f
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lua.c
@@ -0,0 +1,463 @@
1/*
2** $Id: lua.c,v 1.160.1.2 2007/12/28 15:32:23 roberto Exp $
3** Lua stand-alone interpreter
4** See Copyright Notice in lua.h
5*/
6
7
8#include <signal.h>
9#include <stdio.h>
10#include <stdlib.h>
11#include <string.h>
12
13#define lua_c
14
15#include "lua.h"
16
17#include "lauxlib.h"
18#include "lualib.h"
19#include "luajit.h"
20
21
22
23static lua_State *globalL = NULL;
24
25static const char *progname = LUA_PROGNAME;
26
27
28
29static void lstop (lua_State *L, lua_Debug *ar) {
30 (void)ar; /* unused arg. */
31 lua_sethook(L, NULL, 0, 0);
32 luaL_error(L, "interrupted!");
33}
34
35
36static void laction (int i) {
37 signal(i, SIG_DFL); /* if another SIGINT happens before lstop,
38 terminate process (default action) */
39 lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
40}
41
42
43static void print_usage (void) {
44 fprintf(stderr,
45 "usage: %s [options] [script [args]].\n"
46 "Available options are:\n"
47 " -e stat execute string " LUA_QL("stat") "\n"
48 " -l name require library " LUA_QL("name") "\n"
49 " -j cmd perform LuaJIT control command\n"
50 " -O[lvl] set LuaJIT optimization level\n"
51 " -i enter interactive mode after executing " LUA_QL("script") "\n"
52 " -v show version information\n"
53 " -- stop handling options\n"
54 " - execute stdin and stop handling options\n"
55 ,
56 progname);
57 fflush(stderr);
58}
59
60
61static void l_message (const char *pname, const char *msg) {
62 if (pname) fprintf(stderr, "%s: ", pname);
63 fprintf(stderr, "%s\n", msg);
64 fflush(stderr);
65}
66
67
68static int report (lua_State *L, int status) {
69 if (status && !lua_isnil(L, -1)) {
70 const char *msg = lua_tostring(L, -1);
71 if (msg == NULL) msg = "(error object is not a string)";
72 l_message(progname, msg);
73 lua_pop(L, 1);
74 }
75 return status;
76}
77
78
79static int traceback (lua_State *L) {
80 if (!lua_isstring(L, 1)) /* 'message' not a string? */
81 return 1; /* keep it intact */
82 lua_getfield(L, LUA_GLOBALSINDEX, "debug");
83 if (!lua_istable(L, -1)) {
84 lua_pop(L, 1);
85 return 1;
86 }
87 lua_getfield(L, -1, "traceback");
88 if (!lua_isfunction(L, -1)) {
89 lua_pop(L, 2);
90 return 1;
91 }
92 lua_pushvalue(L, 1); /* pass error message */
93 lua_pushinteger(L, 2); /* skip this function and traceback */
94 lua_call(L, 2, 1); /* call debug.traceback */
95 return 1;
96}
97
98
99static int docall (lua_State *L, int narg, int clear) {
100 int status;
101 int base = lua_gettop(L) - narg; /* function index */
102 lua_pushcfunction(L, traceback); /* push traceback function */
103 lua_insert(L, base); /* put it under chunk and args */
104 signal(SIGINT, laction);
105 status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
106 signal(SIGINT, SIG_DFL);
107 lua_remove(L, base); /* remove traceback function */
108 /* force a complete garbage collection in case of errors */
109 if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
110 return status;
111}
112
113
114static void print_version (void) {
115 l_message(NULL, LUA_RELEASE " " LUA_COPYRIGHT);
116 l_message(NULL, LUAJIT_VERSION " " LUAJIT_COPYRIGHT ", " LUAJIT_URL);
117}
118
119
120static int getargs (lua_State *L, char **argv, int n) {
121 int narg;
122 int i;
123 int argc = 0;
124 while (argv[argc]) argc++; /* count total number of arguments */
125 narg = argc - (n + 1); /* number of arguments to the script */
126 luaL_checkstack(L, narg + 3, "too many arguments to script");
127 for (i=n+1; i < argc; i++)
128 lua_pushstring(L, argv[i]);
129 lua_createtable(L, narg, n + 1);
130 for (i=0; i < argc; i++) {
131 lua_pushstring(L, argv[i]);
132 lua_rawseti(L, -2, i - n);
133 }
134 return narg;
135}
136
137
138static int dofile (lua_State *L, const char *name) {
139 int status = luaL_loadfile(L, name) || docall(L, 0, 1);
140 return report(L, status);
141}
142
143
144static int dostring (lua_State *L, const char *s, const char *name) {
145 int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1);
146 return report(L, status);
147}
148
149
150static int dolibrary (lua_State *L, const char *name) {
151 lua_getglobal(L, "require");
152 lua_pushstring(L, name);
153 return report(L, docall(L, 1, 1));
154}
155
156
157static const char *get_prompt (lua_State *L, int firstline) {
158 const char *p;
159 lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");
160 p = lua_tostring(L, -1);
161 if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2);
162 lua_pop(L, 1); /* remove global */
163 return p;
164}
165
166
167static int incomplete (lua_State *L, int status) {
168 if (status == LUA_ERRSYNTAX) {
169 size_t lmsg;
170 const char *msg = lua_tolstring(L, -1, &lmsg);
171 const char *tp = msg + lmsg - (sizeof(LUA_QL("<eof>")) - 1);
172 if (strstr(msg, LUA_QL("<eof>")) == tp) {
173 lua_pop(L, 1);
174 return 1;
175 }
176 }
177 return 0; /* else... */
178}
179
180
181static int pushline (lua_State *L, int firstline) {
182 char buffer[LUA_MAXINPUT];
183 char *b = buffer;
184 size_t l;
185 const char *prmt = get_prompt(L, firstline);
186 if (lua_readline(L, b, prmt) == 0)
187 return 0; /* no input */
188 l = strlen(b);
189 if (l > 0 && b[l-1] == '\n') /* line ends with newline? */
190 b[l-1] = '\0'; /* remove it */
191 if (firstline && b[0] == '=') /* first line starts with `=' ? */
192 lua_pushfstring(L, "return %s", b+1); /* change it to `return' */
193 else
194 lua_pushstring(L, b);
195 lua_freeline(L, b);
196 return 1;
197}
198
199
200static int loadline (lua_State *L) {
201 int status;
202 lua_settop(L, 0);
203 if (!pushline(L, 1))
204 return -1; /* no input */
205 for (;;) { /* repeat until gets a complete line */
206 status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
207 if (!incomplete(L, status)) break; /* cannot try to add lines? */
208 if (!pushline(L, 0)) /* no more input? */
209 return -1;
210 lua_pushliteral(L, "\n"); /* add a new line... */
211 lua_insert(L, -2); /* ...between the two lines */
212 lua_concat(L, 3); /* join them */
213 }
214 lua_saveline(L, 1);
215 lua_remove(L, 1); /* remove line */
216 return status;
217}
218
219
220static void dotty (lua_State *L) {
221 int status;
222 const char *oldprogname = progname;
223 progname = NULL;
224 while ((status = loadline(L)) != -1) {
225 if (status == 0) status = docall(L, 0, 0);
226 report(L, status);
227 if (status == 0 && lua_gettop(L) > 0) { /* any result to print? */
228 lua_getglobal(L, "print");
229 lua_insert(L, 1);
230 if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
231 l_message(progname, lua_pushfstring(L,
232 "error calling " LUA_QL("print") " (%s)",
233 lua_tostring(L, -1)));
234 }
235 }
236 lua_settop(L, 0); /* clear stack */
237 fputs("\n", stdout);
238 fflush(stdout);
239 progname = oldprogname;
240}
241
242
243static int handle_script (lua_State *L, char **argv, int n) {
244 int status;
245 const char *fname;
246 int narg = getargs(L, argv, n); /* collect arguments */
247 lua_setglobal(L, "arg");
248 fname = argv[n];
249 if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0)
250 fname = NULL; /* stdin */
251 status = luaL_loadfile(L, fname);
252 lua_insert(L, -(narg+1));
253 if (status == 0)
254 status = docall(L, narg, 0);
255 else
256 lua_pop(L, narg);
257 return report(L, status);
258}
259
260/* ---- start of LuaJIT extensions */
261
262static int loadjitmodule (lua_State *L, const char *notfound) {
263 lua_getglobal(L, "require");
264 lua_pushliteral(L, "jit.");
265 lua_pushvalue(L, -3);
266 lua_concat(L, 2);
267 if (lua_pcall(L, 1, 1, 0)) {
268 const char *msg = lua_tostring(L, -1);
269 if (msg && !strncmp(msg, "module ", 7)) {
270 l_message(progname, notfound);
271 return 1;
272 }
273 else
274 return report(L, 1);
275 }
276 lua_getfield(L, -1, "start");
277 lua_remove(L, -2); /* drop module table */
278 return 0;
279}
280
281/* JIT engine control command: try jit library first or load add-on module */
282static int dojitcmd (lua_State *L, const char *cmd) {
283 const char *val = strchr(cmd, '=');
284 lua_pushlstring(L, cmd, val ? val - cmd : strlen(cmd));
285 lua_getglobal(L, "jit"); /* get jit.* table */
286 lua_pushvalue(L, -2);
287 lua_gettable(L, -2); /* lookup library function */
288 if (!lua_isfunction(L, -1)) {
289 lua_pop(L, 2); /* drop non-function and jit.* table, keep module name */
290 if (loadjitmodule(L, "unknown luaJIT command"))
291 return 1;
292 }
293 else {
294 lua_remove(L, -2); /* drop jit.* table */
295 }
296 lua_remove(L, -2); /* drop module name */
297 if (val) lua_pushstring(L, val+1);
298 return report(L, lua_pcall(L, val ? 1 : 0, 0, 0));
299}
300
301/* start optimizer */
302static int dojitopt (lua_State *L, const char *opt) {
303 lua_pushliteral(L, "opt");
304 if (loadjitmodule(L, "LuaJIT optimizer module not installed"))
305 return 1;
306 lua_remove(L, -2); /* drop module name */
307 if (*opt) lua_pushstring(L, opt);
308 return report(L, lua_pcall(L, *opt ? 1 : 0, 0, 0));
309}
310
311/* ---- end of LuaJIT extensions */
312
313/* check that argument has no extra characters at the end */
314#define notail(x) {if ((x)[2] != '\0') return -1;}
315
316
317static int collectargs (char **argv, int *pi, int *pv, int *pe) {
318 int i;
319 for (i = 1; argv[i] != NULL; i++) {
320 if (argv[i][0] != '-') /* not an option? */
321 return i;
322 switch (argv[i][1]) { /* option */
323 case '-':
324 notail(argv[i]);
325 return (argv[i+1] != NULL ? i+1 : 0);
326 case '\0':
327 return i;
328 case 'i':
329 notail(argv[i]);
330 *pi = 1; /* go through */
331 case 'v':
332 notail(argv[i]);
333 *pv = 1;
334 break;
335 case 'e':
336 *pe = 1; /* go through */
337 case 'j': /* LuaJIT extension */
338 case 'l':
339 if (argv[i][2] == '\0') {
340 i++;
341 if (argv[i] == NULL) return -1;
342 }
343 break;
344 case 'O': break; /* LuaJIT extension */
345 default: return -1; /* invalid option */
346 }
347 }
348 return 0;
349}
350
351
352static int runargs (lua_State *L, char **argv, int n) {
353 int i;
354 for (i = 1; i < n; i++) {
355 if (argv[i] == NULL) continue;
356 lua_assert(argv[i][0] == '-');
357 switch (argv[i][1]) { /* option */
358 case 'e': {
359 const char *chunk = argv[i] + 2;
360 if (*chunk == '\0') chunk = argv[++i];
361 lua_assert(chunk != NULL);
362 if (dostring(L, chunk, "=(command line)") != 0)
363 return 1;
364 break;
365 }
366 case 'l': {
367 const char *filename = argv[i] + 2;
368 if (*filename == '\0') filename = argv[++i];
369 lua_assert(filename != NULL);
370 if (dolibrary(L, filename))
371 return 1; /* stop if file fails */
372 break;
373 }
374 case 'j': { /* LuaJIT extension */
375 const char *cmd = argv[i] + 2;
376 if (*cmd == '\0') cmd = argv[++i];
377 lua_assert(cmd != NULL);
378 if (dojitcmd(L, cmd))
379 return 1;
380 break;
381 }
382 case 'O': /* LuaJIT extension */
383 if (dojitopt(L, argv[i] + 2))
384 return 1;
385 break;
386 default: break;
387 }
388 }
389 return 0;
390}
391
392
393static int handle_luainit (lua_State *L) {
394 const char *init = getenv(LUA_INIT);
395 if (init == NULL) return 0; /* status OK */
396 else if (init[0] == '@')
397 return dofile(L, init+1);
398 else
399 return dostring(L, init, "=" LUA_INIT);
400}
401
402
403struct Smain {
404 int argc;
405 char **argv;
406 int status;
407};
408
409
410static int pmain (lua_State *L) {
411 struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
412 char **argv = s->argv;
413 int script;
414 int has_i = 0, has_v = 0, has_e = 0;
415 globalL = L;
416 if (argv[0] && argv[0][0]) progname = argv[0];
417 LUAJIT_VERSION_SYM(); /* linker-enforced version check */
418 lua_gc(L, LUA_GCSTOP, 0); /* stop collector during initialization */
419 luaL_openlibs(L); /* open libraries */
420 lua_gc(L, LUA_GCRESTART, 0);
421 s->status = handle_luainit(L);
422 if (s->status != 0) return 0;
423 script = collectargs(argv, &has_i, &has_v, &has_e);
424 if (script < 0) { /* invalid args? */
425 print_usage();
426 s->status = 1;
427 return 0;
428 }
429 if (has_v) print_version();
430 s->status = runargs(L, argv, (script > 0) ? script : s->argc);
431 if (s->status != 0) return 0;
432 if (script)
433 s->status = handle_script(L, argv, script);
434 if (s->status != 0) return 0;
435 if (has_i)
436 dotty(L);
437 else if (script == 0 && !has_e && !has_v) {
438 if (lua_stdin_is_tty()) {
439 print_version();
440 dotty(L);
441 }
442 else dofile(L, NULL); /* executes stdin as a file */
443 }
444 return 0;
445}
446
447
448int main (int argc, char **argv) {
449 int status;
450 struct Smain s;
451 lua_State *L = lua_open(); /* create state */
452 if (L == NULL) {
453 l_message(argv[0], "cannot create state: not enough memory");
454 return EXIT_FAILURE;
455 }
456 s.argc = argc;
457 s.argv = argv;
458 status = lua_cpcall(L, &pmain, &s);
459 report(L, status);
460 lua_close(L);
461 return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
462}
463
diff --git a/libraries/LuaJIT-1.1.7/src/lua.h b/libraries/LuaJIT-1.1.7/src/lua.h
new file mode 100644
index 0000000..7d6ee45
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lua.h
@@ -0,0 +1,385 @@
1/*
2** $Id: lua.h,v 1.218.1.5 2008/08/06 13:30:12 roberto Exp $
3** Lua - An Extensible Extension Language
4** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
5** See Copyright Notice at the end of this file
6*/
7
8
9#ifndef lua_h
10#define lua_h
11
12#include <stdarg.h>
13#include <stddef.h>
14
15
16#include "luaconf.h"
17
18
19#define LUA_VERSION "Lua 5.1"
20#define LUA_RELEASE "Lua 5.1.4"
21#define LUA_VERSION_NUM 501
22#define LUA_COPYRIGHT "Copyright (C) 1994-2008 Lua.org, PUC-Rio"
23#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
24
25
26/* mark for precompiled code (`<esc>Lua') */
27#define LUA_SIGNATURE "\033Lua"
28
29/* option for multiple returns in `lua_pcall' and `lua_call' */
30#define LUA_MULTRET (-1)
31
32
33/*
34** pseudo-indices
35*/
36#define LUA_REGISTRYINDEX (-10000)
37#define LUA_ENVIRONINDEX (-10001)
38#define LUA_GLOBALSINDEX (-10002)
39#define lua_upvalueindex(i) (LUA_GLOBALSINDEX-(i))
40
41
42/* thread status; 0 is OK */
43#define LUA_YIELD 1
44#define LUA_ERRRUN 2
45#define LUA_ERRSYNTAX 3
46#define LUA_ERRMEM 4
47#define LUA_ERRERR 5
48
49
50typedef struct lua_State lua_State;
51
52typedef int (*lua_CFunction) (lua_State *L);
53
54
55/*
56** functions that read/write blocks when loading/dumping Lua chunks
57*/
58typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
59
60typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);
61
62
63/*
64** prototype for memory-allocation functions
65*/
66typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
67
68
69/*
70** basic types
71*/
72#define LUA_TNONE (-1)
73
74#define LUA_TNIL 0
75#define LUA_TBOOLEAN 1
76#define LUA_TLIGHTUSERDATA 2
77#define LUA_TNUMBER 3
78#define LUA_TSTRING 4
79#define LUA_TTABLE 5
80#define LUA_TFUNCTION 6
81#define LUA_TUSERDATA 7
82#define LUA_TTHREAD 8
83
84
85
86/* minimum Lua stack available to a C function */
87#define LUA_MINSTACK 20
88
89
90/*
91** generic extra include file
92*/
93#if defined(LUA_USER_H)
94#include LUA_USER_H
95#endif
96
97
98/* type of numbers in Lua */
99typedef LUA_NUMBER lua_Number;
100
101
102/* type for integer functions */
103typedef LUA_INTEGER lua_Integer;
104
105
106
107/*
108** state manipulation
109*/
110LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
111LUA_API void (lua_close) (lua_State *L);
112LUA_API lua_State *(lua_newthread) (lua_State *L);
113
114LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
115
116
117/*
118** basic stack manipulation
119*/
120LUA_API int (lua_gettop) (lua_State *L);
121LUA_API void (lua_settop) (lua_State *L, int idx);
122LUA_API void (lua_pushvalue) (lua_State *L, int idx);
123LUA_API void (lua_remove) (lua_State *L, int idx);
124LUA_API void (lua_insert) (lua_State *L, int idx);
125LUA_API void (lua_replace) (lua_State *L, int idx);
126LUA_API int (lua_checkstack) (lua_State *L, int sz);
127
128LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n);
129
130
131/*
132** access functions (stack -> C)
133*/
134
135LUA_API int (lua_isnumber) (lua_State *L, int idx);
136LUA_API int (lua_isstring) (lua_State *L, int idx);
137LUA_API int (lua_iscfunction) (lua_State *L, int idx);
138LUA_API int (lua_isuserdata) (lua_State *L, int idx);
139LUA_API int (lua_type) (lua_State *L, int idx);
140LUA_API const char *(lua_typename) (lua_State *L, int tp);
141
142LUA_API int (lua_equal) (lua_State *L, int idx1, int idx2);
143LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2);
144LUA_API int (lua_lessthan) (lua_State *L, int idx1, int idx2);
145
146LUA_API lua_Number (lua_tonumber) (lua_State *L, int idx);
147LUA_API lua_Integer (lua_tointeger) (lua_State *L, int idx);
148LUA_API int (lua_toboolean) (lua_State *L, int idx);
149LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len);
150LUA_API size_t (lua_objlen) (lua_State *L, int idx);
151LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx);
152LUA_API void *(lua_touserdata) (lua_State *L, int idx);
153LUA_API lua_State *(lua_tothread) (lua_State *L, int idx);
154LUA_API const void *(lua_topointer) (lua_State *L, int idx);
155
156
157/*
158** push functions (C -> stack)
159*/
160LUA_API void (lua_pushnil) (lua_State *L);
161LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n);
162LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n);
163LUA_API void (lua_pushlstring) (lua_State *L, const char *s, size_t l);
164LUA_API void (lua_pushstring) (lua_State *L, const char *s);
165LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
166 va_list argp);
167LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
168LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
169LUA_API void (lua_pushboolean) (lua_State *L, int b);
170LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p);
171LUA_API int (lua_pushthread) (lua_State *L);
172
173
174/*
175** get functions (Lua -> stack)
176*/
177LUA_API void (lua_gettable) (lua_State *L, int idx);
178LUA_API void (lua_getfield) (lua_State *L, int idx, const char *k);
179LUA_API void (lua_rawget) (lua_State *L, int idx);
180LUA_API void (lua_rawgeti) (lua_State *L, int idx, int n);
181LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec);
182LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
183LUA_API int (lua_getmetatable) (lua_State *L, int objindex);
184LUA_API void (lua_getfenv) (lua_State *L, int idx);
185
186
187/*
188** set functions (stack -> Lua)
189*/
190LUA_API void (lua_settable) (lua_State *L, int idx);
191LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k);
192LUA_API void (lua_rawset) (lua_State *L, int idx);
193LUA_API void (lua_rawseti) (lua_State *L, int idx, int n);
194LUA_API int (lua_setmetatable) (lua_State *L, int objindex);
195LUA_API int (lua_setfenv) (lua_State *L, int idx);
196
197
198/*
199** `load' and `call' functions (load and run Lua code)
200*/
201LUA_API void (lua_call) (lua_State *L, int nargs, int nresults);
202LUA_API int (lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc);
203LUA_API int (lua_cpcall) (lua_State *L, lua_CFunction func, void *ud);
204LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt,
205 const char *chunkname);
206
207LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
208
209
210/*
211** coroutine functions
212*/
213LUA_API int (lua_yield) (lua_State *L, int nresults);
214LUA_API int (lua_resume) (lua_State *L, int narg);
215LUA_API int (lua_status) (lua_State *L);
216
217/*
218** garbage-collection function and options
219*/
220
221#define LUA_GCSTOP 0
222#define LUA_GCRESTART 1
223#define LUA_GCCOLLECT 2
224#define LUA_GCCOUNT 3
225#define LUA_GCCOUNTB 4
226#define LUA_GCSTEP 5
227#define LUA_GCSETPAUSE 6
228#define LUA_GCSETSTEPMUL 7
229
230LUA_API int (lua_gc) (lua_State *L, int what, int data);
231
232
233/*
234** miscellaneous functions
235*/
236
237LUA_API int (lua_error) (lua_State *L);
238
239LUA_API int (lua_next) (lua_State *L, int idx);
240
241LUA_API void (lua_concat) (lua_State *L, int n);
242
243LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
244LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
245
246
247
248/*
249** ===============================================================
250** some useful macros
251** ===============================================================
252*/
253
254#define lua_pop(L,n) lua_settop(L, -(n)-1)
255
256#define lua_newtable(L) lua_createtable(L, 0, 0)
257
258#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
259
260#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0)
261
262#define lua_strlen(L,i) lua_objlen(L, (i))
263
264#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION)
265#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE)
266#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
267#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL)
268#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN)
269#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD)
270#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE)
271#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0)
272
273#define lua_pushliteral(L, s) \
274 lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
275
276#define lua_setglobal(L,s) lua_setfield(L, LUA_GLOBALSINDEX, (s))
277#define lua_getglobal(L,s) lua_getfield(L, LUA_GLOBALSINDEX, (s))
278
279#define lua_tostring(L,i) lua_tolstring(L, (i), NULL)
280
281
282
283/*
284** compatibility macros and functions
285*/
286
287#define lua_open() luaL_newstate()
288
289#define lua_getregistry(L) lua_pushvalue(L, LUA_REGISTRYINDEX)
290
291#define lua_getgccount(L) lua_gc(L, LUA_GCCOUNT, 0)
292
293#define lua_Chunkreader lua_Reader
294#define lua_Chunkwriter lua_Writer
295
296
297
298/*
299** {======================================================================
300** Debug API
301** =======================================================================
302*/
303
304
305/*
306** Event codes
307*/
308#define LUA_HOOKCALL 0
309#define LUA_HOOKRET 1
310#define LUA_HOOKLINE 2
311#define LUA_HOOKCOUNT 3
312#define LUA_HOOKTAILRET 4
313
314
315/*
316** Event masks
317*/
318#define LUA_MASKCALL (1 << LUA_HOOKCALL)
319#define LUA_MASKRET (1 << LUA_HOOKRET)
320#define LUA_MASKLINE (1 << LUA_HOOKLINE)
321#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT)
322
323typedef struct lua_Debug lua_Debug; /* activation record */
324
325
326/* Functions to be called by the debuger in specific events */
327typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
328
329
330LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar);
331LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
332LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
333LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);
334LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n);
335LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n);
336
337LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count);
338LUA_API lua_Hook lua_gethook (lua_State *L);
339LUA_API int lua_gethookmask (lua_State *L);
340LUA_API int lua_gethookcount (lua_State *L);
341
342
343struct lua_Debug {
344 int event;
345 const char *name; /* (n) */
346 const char *namewhat; /* (n) `global', `local', `field', `method' */
347 const char *what; /* (S) `Lua', `C', `main', `tail' */
348 const char *source; /* (S) */
349 int currentline; /* (l) */
350 int nups; /* (u) number of upvalues */
351 int linedefined; /* (S) */
352 int lastlinedefined; /* (S) */
353 char short_src[LUA_IDSIZE]; /* (S) */
354 /* private part */
355 int i_ci; /* active function */
356};
357
358/* }====================================================================== */
359
360
361/******************************************************************************
362* Copyright (C) 1994-2008 Lua.org, PUC-Rio. All rights reserved.
363*
364* Permission is hereby granted, free of charge, to any person obtaining
365* a copy of this software and associated documentation files (the
366* "Software"), to deal in the Software without restriction, including
367* without limitation the rights to use, copy, modify, merge, publish,
368* distribute, sublicense, and/or sell copies of the Software, and to
369* permit persons to whom the Software is furnished to do so, subject to
370* the following conditions:
371*
372* The above copyright notice and this permission notice shall be
373* included in all copies or substantial portions of the Software.
374*
375* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
376* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
377* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
378* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
379* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
380* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
381* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
382******************************************************************************/
383
384
385#endif
diff --git a/libraries/LuaJIT-1.1.7/src/luac.c b/libraries/LuaJIT-1.1.7/src/luac.c
new file mode 100644
index 0000000..d070173
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/luac.c
@@ -0,0 +1,200 @@
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
26#define PROGNAME "luac" /* default program name */
27#define OUTPUT PROGNAME ".out" /* default output file */
28
29static int listing=0; /* list bytecodes? */
30static int dumping=1; /* dump bytecodes? */
31static int stripping=0; /* strip debug information? */
32static char Output[]={ OUTPUT }; /* default output file name */
33static const char* output=Output; /* actual output file name */
34static const char* progname=PROGNAME; /* actual program name */
35
36static void fatal(const char* message)
37{
38 fprintf(stderr,"%s: %s\n",progname,message);
39 exit(EXIT_FAILURE);
40}
41
42static void cannot(const char* what)
43{
44 fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
45 exit(EXIT_FAILURE);
46}
47
48static void usage(const char* message)
49{
50 if (*message=='-')
51 fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
52 else
53 fprintf(stderr,"%s: %s\n",progname,message);
54 fprintf(stderr,
55 "usage: %s [options] [filenames].\n"
56 "Available options are:\n"
57 " - process stdin\n"
58 " -l list\n"
59 " -o name output to file " LUA_QL("name") " (default is \"%s\")\n"
60 " -p parse only\n"
61 " -s strip debug information\n"
62 " -v show version information\n"
63 " -- stop handling options\n",
64 progname,Output);
65 exit(EXIT_FAILURE);
66}
67
68#define IS(s) (strcmp(argv[i],s)==0)
69
70static int doargs(int argc, char* argv[])
71{
72 int i;
73 int version=0;
74 if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];
75 for (i=1; i<argc; i++)
76 {
77 if (*argv[i]!='-') /* end of options; keep it */
78 break;
79 else if (IS("--")) /* end of options; skip it */
80 {
81 ++i;
82 if (version) ++version;
83 break;
84 }
85 else if (IS("-")) /* end of options; use stdin */
86 break;
87 else if (IS("-l")) /* list */
88 ++listing;
89 else if (IS("-o")) /* output file */
90 {
91 output=argv[++i];
92 if (output==NULL || *output==0) usage(LUA_QL("-o") " needs argument");
93 if (IS("-")) output=NULL;
94 }
95 else if (IS("-p")) /* parse only */
96 dumping=0;
97 else if (IS("-s")) /* strip debug information */
98 stripping=1;
99 else if (IS("-v")) /* show version */
100 ++version;
101 else /* unknown option */
102 usage(argv[i]);
103 }
104 if (i==argc && (listing || !dumping))
105 {
106 dumping=0;
107 argv[--i]=Output;
108 }
109 if (version)
110 {
111 printf("%s %s\n",LUA_RELEASE,LUA_COPYRIGHT);
112 if (version==argc-1) exit(EXIT_SUCCESS);
113 }
114 return i;
115}
116
117#define toproto(L,i) (clvalue(L->top+(i))->l.p)
118
119static const Proto* combine(lua_State* L, int n)
120{
121 if (n==1)
122 return toproto(L,-1);
123 else
124 {
125 int i,pc;
126 Proto* f=luaF_newproto(L);
127 setptvalue2s(L,L->top,f); incr_top(L);
128 f->source=luaS_newliteral(L,"=(" PROGNAME ")");
129 f->maxstacksize=1;
130 pc=2*n+1;
131 f->code=luaM_newvector(L,pc,Instruction);
132 f->sizecode=pc;
133 f->p=luaM_newvector(L,n,Proto*);
134 f->sizep=n;
135 pc=0;
136 for (i=0; i<n; i++)
137 {
138 f->p[i]=toproto(L,i-n-1);
139 f->code[pc++]=CREATE_ABx(OP_CLOSURE,0,i);
140 f->code[pc++]=CREATE_ABC(OP_CALL,0,1,1);
141 }
142 f->code[pc++]=CREATE_ABC(OP_RETURN,0,1,0);
143 return f;
144 }
145}
146
147static int writer(lua_State* L, const void* p, size_t size, void* u)
148{
149 UNUSED(L);
150 return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
151}
152
153struct Smain {
154 int argc;
155 char** argv;
156};
157
158static int pmain(lua_State* L)
159{
160 struct Smain* s = (struct Smain*)lua_touserdata(L, 1);
161 int argc=s->argc;
162 char** argv=s->argv;
163 const Proto* f;
164 int i;
165 if (!lua_checkstack(L,argc)) fatal("too many input files");
166 for (i=0; i<argc; i++)
167 {
168 const char* filename=IS("-") ? NULL : argv[i];
169 if (luaL_loadfile(L,filename)!=0) fatal(lua_tostring(L,-1));
170 }
171 f=combine(L,argc);
172 if (listing) luaU_print(f,listing>1);
173 if (dumping)
174 {
175 FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
176 if (D==NULL) cannot("open");
177 lua_lock(L);
178 luaU_dump(L,f,writer,D,stripping);
179 lua_unlock(L);
180 if (ferror(D)) cannot("write");
181 if (fclose(D)) cannot("close");
182 }
183 return 0;
184}
185
186int main(int argc, char* argv[])
187{
188 lua_State* L;
189 struct Smain s;
190 int i=doargs(argc,argv);
191 argc-=i; argv+=i;
192 if (argc<=0) usage("no input files given");
193 L=lua_open();
194 if (L==NULL) fatal("not enough memory for state");
195 s.argc=argc;
196 s.argv=argv;
197 if (lua_cpcall(L,pmain,&s)!=0) fatal(lua_tostring(L,-1));
198 lua_close(L);
199 return EXIT_SUCCESS;
200}
diff --git a/libraries/LuaJIT-1.1.7/src/luaconf.h b/libraries/LuaJIT-1.1.7/src/luaconf.h
new file mode 100644
index 0000000..35a6bd1
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/luaconf.h
@@ -0,0 +1,786 @@
1/*
2** $Id: luaconf.h,v 1.82.1.7 2008/02/11 16:25:08 roberto Exp $
3** Configuration file for Lua
4** See Copyright Notice in lua.h
5*/
6
7
8#ifndef lconfig_h
9#define lconfig_h
10
11#include <limits.h>
12#include <stddef.h>
13
14
15/*
16** ==================================================================
17** Search for "@@" to find all configurable definitions.
18** ===================================================================
19*/
20
21
22/*
23@@ LUA_ANSI controls the use of non-ansi features.
24** CHANGE it (define it) if you want Lua to avoid the use of any
25** non-ansi feature or library.
26*/
27#if defined(__STRICT_ANSI__)
28#define LUA_ANSI
29#endif
30
31
32#if !defined(LUA_ANSI) && defined(_WIN32)
33#define LUA_WIN
34#endif
35
36#if defined(LUA_USE_LINUX)
37#define LUA_USE_POSIX
38#define LUA_USE_DLOPEN /* needs an extra library: -ldl */
39/* #define LUA_USE_READLINE */ /* needs some extra libraries */
40#endif
41
42#if defined(LUA_USE_MACOSX)
43#define LUA_USE_POSIX
44#define LUA_DL_DYLD /* does not need extra library */
45#endif
46
47
48
49/*
50@@ LUA_USE_POSIX includes all functionallity listed as X/Open System
51@* Interfaces Extension (XSI).
52** CHANGE it (define it) if your system is XSI compatible.
53*/
54#if defined(LUA_USE_POSIX)
55#define LUA_USE_MKSTEMP
56#define LUA_USE_ISATTY
57#define LUA_USE_POPEN
58#define LUA_USE_ULONGJMP
59#endif
60
61
62/*
63@@ LUA_PATH and LUA_CPATH are the names of the environment variables that
64@* Lua check to set its paths.
65@@ LUA_INIT is the name of the environment variable that Lua
66@* checks for initialization code.
67** CHANGE them if you want different names.
68*/
69#define LUA_PATH "LUA_PATH"
70#define LUA_CPATH "LUA_CPATH"
71#define LUA_INIT "LUA_INIT"
72
73
74/*
75@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
76@* Lua libraries.
77@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
78@* C libraries.
79** CHANGE them if your machine has a non-conventional directory
80** hierarchy or if you want to install your libraries in
81** non-conventional directories.
82*/
83#if defined(_WIN32)
84/*
85** In Windows, any exclamation mark ('!') in the path is replaced by the
86** path of the directory of the executable file of the current process.
87*/
88#define LUA_LDIR "!\\lua\\"
89#define LUA_CDIR "!\\"
90#define LUA_PATH_DEFAULT \
91 ".\\?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \
92 LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua"
93#define LUA_CPATH_DEFAULT \
94 ".\\?.dll;" LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll"
95
96#else
97#define LUA_ROOT "/usr/local/"
98#define LUA_LDIR LUA_ROOT "share/lua/5.1/"
99#define LUA_CDIR LUA_ROOT "lib/lua/5.1/"
100#define LUA_PATH_DEFAULT \
101 "./?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \
102 LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua"
103#define LUA_CPATH_DEFAULT \
104 "./?.so;" LUA_CDIR"?.so;" LUA_CDIR"loadall.so"
105#endif
106
107
108/*
109@@ LUA_DIRSEP is the directory separator (for submodules).
110** CHANGE it if your machine does not use "/" as the directory separator
111** and is not Windows. (On Windows Lua automatically uses "\".)
112*/
113#if defined(_WIN32)
114#define LUA_DIRSEP "\\"
115#else
116#define LUA_DIRSEP "/"
117#endif
118
119
120/*
121@@ LUA_PATHSEP is the character that separates templates in a path.
122@@ LUA_PATH_MARK is the string that marks the substitution points in a
123@* template.
124@@ LUA_EXECDIR in a Windows path is replaced by the executable's
125@* directory.
126@@ LUA_IGMARK is a mark to ignore all before it when bulding the
127@* luaopen_ function name.
128** CHANGE them if for some reason your system cannot use those
129** characters. (E.g., if one of those characters is a common character
130** in file/directory names.) Probably you do not need to change them.
131*/
132#define LUA_PATHSEP ";"
133#define LUA_PATH_MARK "?"
134#define LUA_EXECDIR "!"
135#define LUA_IGMARK "-"
136
137
138/*
139@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.
140** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
141** machines, ptrdiff_t gives a good choice between int or long.)
142*/
143#define LUA_INTEGER ptrdiff_t
144
145
146/*
147@@ LUA_API is a mark for all core API functions.
148@@ LUALIB_API is a mark for all standard library functions.
149** CHANGE them if you need to define those functions in some special way.
150** For instance, if you want to create one Windows DLL with the core and
151** the libraries, you may want to use the following definition (define
152** LUA_BUILD_AS_DLL to get it).
153*/
154#if defined(LUA_BUILD_AS_DLL)
155
156#if defined(LUA_CORE) || defined(LUA_LIB)
157#define LUA_API __declspec(dllexport)
158#else
159#define LUA_API __declspec(dllimport)
160#endif
161
162#else
163
164#define LUA_API extern
165
166#endif
167
168/* more often than not the libs go together with the core */
169#define LUALIB_API LUA_API
170
171
172/*
173@@ LUAI_FUNC is a mark for all extern functions that are not to be
174@* exported to outside modules.
175@@ LUAI_DATA is a mark for all extern (const) variables that are not to
176@* be exported to outside modules.
177** CHANGE them if you need to mark them in some special way. Elf/gcc
178** (versions 3.2 and later) mark them as "hidden" to optimize access
179** when Lua is compiled as a shared library.
180*/
181#if defined(luaall_c)
182#define LUAI_FUNC static
183#define LUAI_DATA /* empty */
184
185#elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
186 defined(__ELF__)
187#define LUAI_FUNC __attribute__((visibility("hidden"))) extern
188#define LUAI_DATA LUAI_FUNC
189
190#else
191#define LUAI_FUNC extern
192#define LUAI_DATA extern
193#endif
194
195
196
197/*
198@@ LUA_QL describes how error messages quote program elements.
199** CHANGE it if you want a different appearance.
200*/
201#define LUA_QL(x) "'" x "'"
202#define LUA_QS LUA_QL("%s")
203
204
205/*
206@@ LUA_IDSIZE gives the maximum size for the description of the source
207@* of a function in debug information.
208** CHANGE it if you want a different size.
209*/
210#define LUA_IDSIZE 60
211
212
213/*
214** {==================================================================
215** Stand-alone configuration
216** ===================================================================
217*/
218
219#if defined(lua_c) || defined(luaall_c)
220
221/*
222@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that
223@* is, whether we're running lua interactively).
224** CHANGE it if you have a better definition for non-POSIX/non-Windows
225** systems.
226*/
227#if defined(LUA_USE_ISATTY)
228#include <unistd.h>
229#define lua_stdin_is_tty() isatty(0)
230#elif defined(LUA_WIN)
231#include <io.h>
232#include <stdio.h>
233#define lua_stdin_is_tty() _isatty(_fileno(stdin))
234#else
235#define lua_stdin_is_tty() 1 /* assume stdin is a tty */
236#endif
237
238
239/*
240@@ LUA_PROMPT is the default prompt used by stand-alone Lua.
241@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua.
242** CHANGE them if you want different prompts. (You can also change the
243** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.)
244*/
245#define LUA_PROMPT "> "
246#define LUA_PROMPT2 ">> "
247
248
249/*
250@@ LUA_PROGNAME is the default name for the stand-alone Lua program.
251** CHANGE it if your stand-alone interpreter has a different name and
252** your system is not able to detect that name automatically.
253*/
254#define LUA_PROGNAME "luajit"
255
256
257/*
258@@ LUA_MAXINPUT is the maximum length for an input line in the
259@* stand-alone interpreter.
260** CHANGE it if you need longer lines.
261*/
262#define LUA_MAXINPUT 512
263
264
265/*
266@@ lua_readline defines how to show a prompt and then read a line from
267@* the standard input.
268@@ lua_saveline defines how to "save" a read line in a "history".
269@@ lua_freeline defines how to free a line read by lua_readline.
270** CHANGE them if you want to improve this functionality (e.g., by using
271** GNU readline and history facilities).
272*/
273#if defined(LUA_USE_READLINE)
274#include <stdio.h>
275#include <readline/readline.h>
276#include <readline/history.h>
277#define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL)
278#define lua_saveline(L,idx) \
279 if (lua_strlen(L,idx) > 0) /* non-empty line? */ \
280 add_history(lua_tostring(L, idx)); /* add it to history */
281#define lua_freeline(L,b) ((void)L, free(b))
282#else
283#define lua_readline(L,b,p) \
284 ((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \
285 fgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */
286#define lua_saveline(L,idx) { (void)L; (void)idx; }
287#define lua_freeline(L,b) { (void)L; (void)b; }
288#endif
289
290#endif
291
292/* }================================================================== */
293
294
295/*
296@@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles
297@* as a percentage.
298** CHANGE it if you want the GC to run faster or slower (higher values
299** mean larger pauses which mean slower collection.) You can also change
300** this value dynamically.
301*/
302#define LUAI_GCPAUSE 200 /* 200% (wait memory to double before next GC) */
303
304
305/*
306@@ LUAI_GCMUL defines the default speed of garbage collection relative to
307@* memory allocation as a percentage.
308** CHANGE it if you want to change the granularity of the garbage
309** collection. (Higher values mean coarser collections. 0 represents
310** infinity, where each step performs a full collection.) You can also
311** change this value dynamically.
312*/
313#define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */
314
315
316
317/*
318@@ LUA_COMPAT_GETN controls compatibility with old getn behavior.
319** CHANGE it (define it) if you want exact compatibility with the
320** behavior of setn/getn in Lua 5.0.
321**
322** Note: this is not supported by LuaJIT. Leave it undefined.
323*/
324#undef LUA_COMPAT_GETN
325
326/*
327@@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib.
328** CHANGE it to undefined as soon as you do not need a global 'loadlib'
329** function (the function is still available as 'package.loadlib').
330*/
331#undef LUA_COMPAT_LOADLIB
332
333/*
334@@ LUA_COMPAT_VARARG controls compatibility with old vararg feature.
335** CHANGE it to undefined as soon as your programs use only '...' to
336** access vararg parameters (instead of the old 'arg' table).
337**
338** Note: this has a slightly negative performance impact with LuaJIT
339** for all vararg functions. Leave it off if possible and upgrade your
340** code (replace unpack(arg) with ... and/or add local arg = {...}).
341*/
342#undef LUA_COMPAT_VARARG
343
344/*
345@@ LUA_COMPAT_MOD controls compatibility with old math.mod function.
346** CHANGE it to undefined as soon as your programs use 'math.fmod' or
347** the new '%' operator instead of 'math.mod'.
348*/
349#define LUA_COMPAT_MOD
350
351/*
352@@ LUA_COMPAT_LSTR controls compatibility with old long string nesting
353@* facility.
354** CHANGE it to 2 if you want the old behaviour, or undefine it to turn
355** off the advisory error when nesting [[...]].
356*/
357#define LUA_COMPAT_LSTR 1
358
359/*
360@@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name.
361** CHANGE it to undefined as soon as you rename 'string.gfind' to
362** 'string.gmatch'.
363*/
364#define LUA_COMPAT_GFIND
365
366/*
367@@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib'
368@* behavior.
369** CHANGE it to undefined as soon as you replace to 'luaL_register'
370** your uses of 'luaL_openlib'
371*/
372#define LUA_COMPAT_OPENLIB
373
374
375
376/*
377@@ luai_apicheck is the assert macro used by the Lua-C API.
378** CHANGE luai_apicheck if you want Lua to perform some checks in the
379** parameters it gets from API calls. This may slow down the interpreter
380** a bit, but may be quite useful when debugging C code that interfaces
381** with Lua. A useful redefinition is to use assert.h.
382*/
383#if defined(LUA_USE_APICHECK)
384#include <assert.h>
385#define luai_apicheck(L,o) { (void)L; assert(o); }
386#else
387#define luai_apicheck(L,o) { (void)L; }
388#endif
389
390
391/*
392@@ LUAI_BITSINT defines the number of bits in an int.
393** CHANGE here if Lua cannot automatically detect the number of bits of
394** your machine. Probably you do not need to change this.
395*/
396/* avoid overflows in comparison */
397#if INT_MAX-20 < 32760
398#define LUAI_BITSINT 16
399#elif INT_MAX > 2147483640L
400/* int has at least 32 bits */
401#define LUAI_BITSINT 32
402#else
403#error "you must define LUA_BITSINT with number of bits in an integer"
404#endif
405
406
407/*
408@@ LUAI_UINT32 is an unsigned integer with at least 32 bits.
409@@ LUAI_INT32 is an signed integer with at least 32 bits.
410@@ LUAI_UMEM is an unsigned integer big enough to count the total
411@* memory used by Lua.
412@@ LUAI_MEM is a signed integer big enough to count the total memory
413@* used by Lua.
414** CHANGE here if for some weird reason the default definitions are not
415** good enough for your machine. (The definitions in the 'else'
416** part always works, but may waste space on machines with 64-bit
417** longs.) Probably you do not need to change this.
418*/
419#if LUAI_BITSINT >= 32
420#define LUAI_UINT32 unsigned int
421#define LUAI_INT32 int
422#define LUAI_MAXINT32 INT_MAX
423#define LUAI_UMEM size_t
424#define LUAI_MEM ptrdiff_t
425#else
426/* 16-bit ints */
427#define LUAI_UINT32 unsigned long
428#define LUAI_INT32 long
429#define LUAI_MAXINT32 LONG_MAX
430#define LUAI_UMEM unsigned long
431#define LUAI_MEM long
432#endif
433
434
435/*
436@@ LUAI_MAXCALLS limits the number of nested calls.
437** CHANGE it if you need really deep recursive calls. This limit is
438** arbitrary; its only purpose is to stop infinite recursion before
439** exhausting memory.
440*/
441#define LUAI_MAXCALLS 20000
442
443
444/*
445@@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function
446@* can use.
447** CHANGE it if you need lots of (Lua) stack space for your C
448** functions. This limit is arbitrary; its only purpose is to stop C
449** functions to consume unlimited stack space. (must be smaller than
450** -LUA_REGISTRYINDEX)
451*/
452#define LUAI_MAXCSTACK 8000
453
454
455/*
456** {==================================================================
457** CHANGE (to smaller values) the following definitions if your system
458** has a small C stack. (Or you may want to change them to larger
459** values if your system has a large C stack and these limits are
460** too rigid for you.) Some of these constants control the size of
461** stack-allocated arrays used by the compiler or the interpreter, while
462** others limit the maximum number of recursive calls that the compiler
463** or the interpreter can perform. Values too large may cause a C stack
464** overflow for some forms of deep constructs.
465** ===================================================================
466*/
467
468
469/*
470@@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and
471@* syntactical nested non-terminals in a program.
472*/
473#define LUAI_MAXCCALLS 200
474
475
476/*
477@@ LUAI_MAXVARS is the maximum number of local variables per function
478@* (must be smaller than 250).
479*/
480#define LUAI_MAXVARS 200
481
482
483/*
484@@ LUAI_MAXUPVALUES is the maximum number of upvalues per function
485@* (must be smaller than 250).
486*/
487#define LUAI_MAXUPVALUES 60
488
489
490/*
491@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
492*/
493#define LUAL_BUFFERSIZE BUFSIZ
494
495/* }================================================================== */
496
497
498
499
500/*
501** {==================================================================
502@@ LUA_NUMBER is the type of numbers in Lua.
503** CHANGE the following definitions only if you want to build Lua
504** with a number type different from double. You may also need to
505** change lua_number2int & lua_number2integer.
506** ===================================================================
507*/
508
509#define LUA_NUMBER_DOUBLE
510#define LUA_NUMBER double
511
512/*
513@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
514@* over a number.
515*/
516#define LUAI_UACNUMBER double
517
518
519/*
520@@ LUA_NUMBER_SCAN is the format for reading numbers.
521@@ LUA_NUMBER_FMT is the format for writing numbers.
522@@ lua_number2str converts a number to a string.
523@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
524@@ lua_str2number converts a string to a number.
525*/
526#define LUA_NUMBER_SCAN "%lf"
527#define LUA_NUMBER_FMT "%.14g"
528#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))
529#define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */
530#define lua_str2number(s,p) strtod((s), (p))
531
532
533/*
534@@ The luai_num* macros define the primitive operations over numbers.
535*/
536#if defined(LUA_CORE)
537#include <math.h>
538#define luai_numadd(a,b) ((a)+(b))
539#define luai_numsub(a,b) ((a)-(b))
540#define luai_nummul(a,b) ((a)*(b))
541#define luai_numdiv(a,b) ((a)/(b))
542#define luai_nummod(a,b) ((a) - floor((a)/(b))*(b))
543#define luai_numpow(a,b) (pow(a,b))
544#define luai_numunm(a) (-(a))
545#define luai_numeq(a,b) ((a)==(b))
546#define luai_numlt(a,b) ((a)<(b))
547#define luai_numle(a,b) ((a)<=(b))
548#define luai_numisnan(a) (!luai_numeq((a), (a)))
549#endif
550
551
552/*
553@@ lua_number2int is a macro to convert lua_Number to int.
554@@ lua_number2integer is a macro to convert lua_Number to lua_Integer.
555** CHANGE them if you know a faster way to convert a lua_Number to
556** int (with any rounding method and without throwing errors) in your
557** system. In Pentium machines, a naive typecast from double to int
558** in C is extremely slow, so any alternative is worth trying.
559*/
560
561/* On a Pentium, resort to a trick */
562#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \
563 (defined(__i386) || defined (_M_IX86) || defined(__i386__))
564
565/* On a Microsoft compiler, use assembler */
566#if defined(_MSC_VER)
567
568#define lua_number2int(i,d) __asm fld d __asm fistp i
569#define lua_number2integer(i,n) lua_number2int(i, n)
570
571/* the next trick should work on any Pentium, but sometimes clashes
572 with a DirectX idiosyncrasy */
573#else
574
575union luai_Cast { double l_d; long l_l; };
576#define lua_number2int(i,d) \
577 { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }
578#define lua_number2integer(i,n) lua_number2int(i, n)
579
580#endif
581
582
583/* this option always works, but may be slow */
584#else
585#define lua_number2int(i,d) ((i)=(int)(d))
586#define lua_number2integer(i,d) ((i)=(lua_Integer)(d))
587
588#endif
589
590
591/*
592@@ LUA_TVALUE_ALIGN specifies extra alignment constraints for the
593@@ tagged value structure to get better lua_Number alignment.
594** CHANGE it to an empty define if you want to save some space
595** at the cost of execution time. Note that this is only needed
596** for the x86 ABI on most POSIX systems, but not on Windows and
597** not for most other CPUs. If you change it then you need to follow
598** the instructions in ljit_x86.dash, too (look for TVALUE_SIZE).
599*/
600
601#if defined(LUA_NUMBER_DOUBLE) && defined(__GNUC__) && \
602 (defined(__i386) || defined(__i386__)) && !defined(_WIN32)
603#define LUA_TVALUE_ALIGN __attribute__ ((aligned(8)))
604#else
605#define LUA_TVALUE_ALIGN
606#endif
607
608/* }================================================================== */
609
610
611/*
612@@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment.
613** CHANGE it if your system requires alignments larger than double. (For
614** instance, if your system supports long doubles and they must be
615** aligned in 16-byte boundaries, then you should add long double in the
616** union.) Probably you do not need to change this.
617*/
618#define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; }
619
620
621/*
622@@ LUAI_THROW/LUAI_TRY define how Lua does exception handling.
623** CHANGE them if you prefer to use longjmp/setjmp even with C++
624** or if want/don't to use _longjmp/_setjmp instead of regular
625** longjmp/setjmp. By default, Lua handles errors with exceptions when
626** compiling as C++ code, with _longjmp/_setjmp when asked to use them,
627** and with longjmp/setjmp otherwise.
628*/
629#if defined(__cplusplus)
630/* C++ exceptions */
631#define LUAI_THROW(L,c) throw(c)
632#define LUAI_TRY(L,c,a) try { a } catch(...) \
633 { if ((c)->status == 0) (c)->status = -1; }
634#define luai_jmpbuf int /* dummy variable */
635
636#elif defined(LUA_USE_ULONGJMP)
637/* in Unix, try _longjmp/_setjmp (more efficient) */
638#define LUAI_THROW(L,c) _longjmp((c)->b, 1)
639#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }
640#define luai_jmpbuf jmp_buf
641
642#else
643/* default handling with long jumps */
644#define LUAI_THROW(L,c) longjmp((c)->b, 1)
645#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }
646#define luai_jmpbuf jmp_buf
647
648#endif
649
650
651/*
652@@ LUA_MAXCAPTURES is the maximum number of captures that a pattern
653@* can do during pattern-matching.
654** CHANGE it if you need more captures. This limit is arbitrary.
655*/
656#define LUA_MAXCAPTURES 32
657
658
659/*
660@@ lua_tmpnam is the function that the OS library uses to create a
661@* temporary name.
662@@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam.
663** CHANGE them if you have an alternative to tmpnam (which is considered
664** insecure) or if you want the original tmpnam anyway. By default, Lua
665** uses tmpnam except when POSIX is available, where it uses mkstemp.
666*/
667#if defined(loslib_c) || defined(luaall_c)
668
669#if defined(LUA_USE_MKSTEMP)
670#include <unistd.h>
671#define LUA_TMPNAMBUFSIZE 32
672#define lua_tmpnam(b,e) { \
673 strcpy(b, "/tmp/lua_XXXXXX"); \
674 e = mkstemp(b); \
675 if (e != -1) close(e); \
676 e = (e == -1); }
677
678#else
679#define LUA_TMPNAMBUFSIZE L_tmpnam
680#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); }
681#endif
682
683#endif
684
685
686/*
687@@ lua_popen spawns a new process connected to the current one through
688@* the file streams.
689** CHANGE it if you have a way to implement it in your system.
690*/
691#if defined(LUA_USE_POPEN)
692
693#define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m))
694#define lua_pclose(L,file) ((void)L, (pclose(file) != -1))
695
696#elif defined(LUA_WIN)
697
698#define lua_popen(L,c,m) ((void)L, _popen(c,m))
699#define lua_pclose(L,file) ((void)L, (_pclose(file) != -1))
700
701#else
702
703#define lua_popen(L,c,m) ((void)((void)c, m), \
704 luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
705#define lua_pclose(L,file) ((void)((void)L, file), 0)
706
707#endif
708
709/*
710@@ LUA_DL_* define which dynamic-library system Lua should use.
711** CHANGE here if Lua has problems choosing the appropriate
712** dynamic-library system for your platform (either Windows' DLL, Mac's
713** dyld, or Unix's dlopen). If your system is some kind of Unix, there
714** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for
715** it. To use dlopen you also need to adapt the src/Makefile (probably
716** adding -ldl to the linker options), so Lua does not select it
717** automatically. (When you change the makefile to add -ldl, you must
718** also add -DLUA_USE_DLOPEN.)
719** If you do not want any kind of dynamic library, undefine all these
720** options.
721** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD.
722*/
723#if defined(LUA_USE_DLOPEN)
724#define LUA_DL_DLOPEN
725#endif
726
727#if defined(LUA_WIN)
728#define LUA_DL_DLL
729#endif
730
731
732/*
733@@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State
734@* (the data goes just *before* the lua_State pointer).
735** CHANGE (define) this if you really need that. This value must be
736** a multiple of the maximum alignment required for your machine.
737*/
738#define LUAI_EXTRASPACE 0
739
740
741/*
742@@ luai_userstate* allow user-specific actions on threads.
743** CHANGE them if you defined LUAI_EXTRASPACE and need to do something
744** extra when a thread is created/deleted/resumed/yielded.
745*/
746#define luai_userstateopen(L) ((void)L)
747#define luai_userstateclose(L) ((void)L)
748#define luai_userstatethread(L,L1) ((void)L)
749#define luai_userstatefree(L) ((void)L)
750#define luai_userstateresume(L,n) ((void)L)
751#define luai_userstateyield(L,n) ((void)L)
752
753
754/*
755@@ LUA_INTFRMLEN is the length modifier for integer conversions
756@* in 'string.format'.
757@@ LUA_INTFRM_T is the integer type correspoding to the previous length
758@* modifier.
759** CHANGE them if your system supports long long or does not support long.
760*/
761
762#if defined(LUA_USELONGLONG)
763
764#define LUA_INTFRMLEN "ll"
765#define LUA_INTFRM_T long long
766
767#else
768
769#define LUA_INTFRMLEN "l"
770#define LUA_INTFRM_T long
771
772#endif
773
774
775
776/* =================================================================== */
777
778/*
779** Local configuration. You can use this space to add your redefinitions
780** without modifying the main part of the file.
781*/
782
783
784
785#endif
786
diff --git a/libraries/LuaJIT-1.1.7/src/luajit.h b/libraries/LuaJIT-1.1.7/src/luajit.h
new file mode 100644
index 0000000..fa32e17
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/luajit.h
@@ -0,0 +1,68 @@
1/*
2** Copyright (C) 2005-2011 Mike Pall. All rights reserved.
3**
4** Permission is hereby granted, free of charge, to any person obtaining
5** a copy of this software and associated documentation files (the
6** "Software"), to deal in the Software without restriction, including
7** without limitation the rights to use, copy, modify, merge, publish,
8** distribute, sublicense, and/or sell copies of the Software, and to
9** permit persons to whom the Software is furnished to do so, subject to
10** the following conditions:
11**
12** The above copyright notice and this permission notice shall be
13** included in all copies or substantial portions of the Software.
14**
15** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
19** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
20** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
21** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22**
23** [ MIT license: http://www.opensource.org/licenses/mit-license.php ]
24*/
25
26/* LuaJIT -- a Just-In-Time Compiler for Lua. http://luajit.org/ */
27
28/* LuaJIT public C API. */
29#ifndef luajit_h
30#define luajit_h
31
32#include "lua.h"
33
34
35#define LUAJIT_VERSION "LuaJIT 1.1.7"
36#define LUAJIT_VERSION_NUM 10107 /* Version 1.1.7 = 01.01.07. */
37#define LUAJIT_VERSION_SYM luaJIT_version_1_1_7
38#define LUAJIT_COPYRIGHT "Copyright (C) 2005-2011 Mike Pall"
39#define LUAJIT_URL "http://luajit.org/"
40
41/* Modes for luaJIT_setmode. */
42#define LUAJIT_MODE_MASK 0x00ff
43
44enum {
45 LUAJIT_MODE_ENGINE, /* Set mode for whole JIT engine. */
46 LUAJIT_MODE_DEBUG, /* Set debug mode (idx = level). */
47
48 LUAJIT_MODE_FUNC, /* Change mode for a function. */
49 LUAJIT_MODE_ALLFUNC, /* Recurse into subroutine protos. */
50 LUAJIT_MODE_ALLSUBFUNC, /* Change only the subroutines. */
51 LUAJIT_MODE_MAX
52};
53
54/* Flags or'ed in to the mode. */
55#define LUAJIT_MODE_OFF 0x0000 /* Disable JIT compilation. */
56#define LUAJIT_MODE_ON 0x0100 /* (Re-)enable JIT compilation. */
57
58
59/* Compile a Lua function. Pass arguments as hints. */
60LUA_API int luaJIT_compile(lua_State *L, int nargs);
61
62/* Set the JIT mode for the whole engine or a function (idx = 0: self). */
63LUA_API int luaJIT_setmode(lua_State *L, int idx, int mode);
64
65/* Enforce (dynamic) linker error for version mismatches. Call from main. */
66LUA_API void LUAJIT_VERSION_SYM(void);
67
68#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lualib.h b/libraries/LuaJIT-1.1.7/src/lualib.h
new file mode 100644
index 0000000..c4567e9
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lualib.h
@@ -0,0 +1,56 @@
1/*
2** $Id: lualib.h,v 1.36 2005/12/27 17:12:00 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"
19LUALIB_API int (luaopen_base) (lua_State *L);
20
21#define LUA_TABLIBNAME "table"
22LUALIB_API int (luaopen_table) (lua_State *L);
23
24#define LUA_IOLIBNAME "io"
25LUALIB_API int (luaopen_io) (lua_State *L);
26
27#define LUA_OSLIBNAME "os"
28LUALIB_API int (luaopen_os) (lua_State *L);
29
30#define LUA_STRLIBNAME "string"
31LUALIB_API int (luaopen_string) (lua_State *L);
32
33#define LUA_MATHLIBNAME "math"
34LUALIB_API int (luaopen_math) (lua_State *L);
35
36#define LUA_DBLIBNAME "debug"
37LUALIB_API int (luaopen_debug) (lua_State *L);
38
39#define LUA_LOADLIBNAME "package"
40LUALIB_API int (luaopen_package) (lua_State *L);
41
42#define LUA_JITLIBNAME "jit"
43LUALIB_API int (luaopen_jit) (lua_State *L);
44
45
46/* open all previous libraries */
47LUALIB_API void (luaL_openlibs) (lua_State *L);
48
49
50
51#ifndef lua_assert
52#define lua_assert(x) ((void)0)
53#endif
54
55
56#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lundump.c b/libraries/LuaJIT-1.1.7/src/lundump.c
new file mode 100644
index 0000000..8010a45
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lundump.c
@@ -0,0 +1,227 @@
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
23typedef 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
36static 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
48static 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
54static int LoadChar(LoadState* S)
55{
56 char x;
57 LoadVar(S,x);
58 return x;
59}
60
61static int LoadInt(LoadState* S)
62{
63 int x;
64 LoadVar(S,x);
65 IF (x<0, "bad integer");
66 return x;
67}
68
69static lua_Number LoadNumber(LoadState* S)
70{
71 lua_Number x;
72 LoadVar(S,x);
73 return x;
74}
75
76static 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
90static 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
98static Proto* LoadFunction(LoadState* S, TString* p);
99
100static 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
137static 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
161static 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
183static 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*/
195Proto* 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*/
214void 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}
diff --git a/libraries/LuaJIT-1.1.7/src/lundump.h b/libraries/LuaJIT-1.1.7/src/lundump.h
new file mode 100644
index 0000000..c80189d
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lundump.h
@@ -0,0 +1,36 @@
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 */
14LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
15
16/* make header; from lundump.c */
17LUAI_FUNC void luaU_header (char* h);
18
19/* dump one chunk; from ldump.c */
20LUAI_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 */
24LUAI_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
diff --git a/libraries/LuaJIT-1.1.7/src/lvm.c b/libraries/LuaJIT-1.1.7/src/lvm.c
new file mode 100644
index 0000000..d24f43c
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lvm.c
@@ -0,0 +1,766 @@
1/*
2** $Id: lvm.c,v 2.63.1.3 2007/12/28 15:32:23 roberto Exp $
3** Lua virtual machine
4** See Copyright Notice in lua.h
5*/
6
7
8#include <stdio.h>
9#include <stdlib.h>
10#include <string.h>
11
12#define lvm_c
13#define LUA_CORE
14
15#include "lua.h"
16
17#include "ldebug.h"
18#include "ldo.h"
19#include "lfunc.h"
20#include "lgc.h"
21#include "lobject.h"
22#include "lopcodes.h"
23#include "lstate.h"
24#include "lstring.h"
25#include "ltable.h"
26#include "ltm.h"
27#include "lvm.h"
28
29
30
31/* limit for table tag-method chains (to avoid loops) */
32#define MAXTAGLOOP 100
33
34
35const TValue *luaV_tonumber (const TValue *obj, TValue *n) {
36 lua_Number num;
37 if (ttisnumber(obj)) return obj;
38 if (ttisstring(obj) && luaO_str2d(svalue(obj), &num)) {
39 setnvalue(n, num);
40 return n;
41 }
42 else
43 return NULL;
44}
45
46
47int luaV_tostring (lua_State *L, StkId obj) {
48 if (!ttisnumber(obj))
49 return 0;
50 else {
51 char s[LUAI_MAXNUMBER2STR];
52 lua_Number n = nvalue(obj);
53 lua_number2str(s, n);
54 setsvalue2s(L, obj, luaS_new(L, s));
55 return 1;
56 }
57}
58
59
60static void traceexec (lua_State *L, const Instruction *pc) {
61 lu_byte mask = L->hookmask;
62 const Instruction *oldpc = L->savedpc;
63 L->savedpc = pc;
64 if ((mask & LUA_MASKCOUNT) && L->hookcount == 0) {
65 resethookcount(L);
66 luaD_callhook(L, LUA_HOOKCOUNT, -1);
67 }
68 if (mask & LUA_MASKLINE) {
69 Proto *p = ci_func(L->ci)->l.p;
70 int npc = pcRel(pc, p);
71 int newline = getline(p, npc);
72 /* call linehook when enter a new function, when jump back (loop),
73 or when enter a new line */
74 if (npc == 0 || pc <= oldpc || newline != getline(p, pcRel(oldpc, p)))
75 luaD_callhook(L, LUA_HOOKLINE, newline);
76 }
77}
78
79
80static void callTMres (lua_State *L, StkId res, const TValue *f,
81 const TValue *p1, const TValue *p2) {
82 ptrdiff_t result = savestack(L, res);
83 setobj2s(L, L->top, f); /* push function */
84 setobj2s(L, L->top+1, p1); /* 1st argument */
85 setobj2s(L, L->top+2, p2); /* 2nd argument */
86 luaD_checkstack(L, 3);
87 L->top += 3;
88 luaD_call(L, L->top - 3, 1);
89 res = restorestack(L, result);
90 L->top--;
91 setobjs2s(L, res, L->top);
92}
93
94
95
96static void callTM (lua_State *L, const TValue *f, const TValue *p1,
97 const TValue *p2, const TValue *p3) {
98 setobj2s(L, L->top, f); /* push function */
99 setobj2s(L, L->top+1, p1); /* 1st argument */
100 setobj2s(L, L->top+2, p2); /* 2nd argument */
101 setobj2s(L, L->top+3, p3); /* 3th argument */
102 luaD_checkstack(L, 4);
103 L->top += 4;
104 luaD_call(L, L->top - 4, 0);
105}
106
107
108void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {
109 int loop;
110 for (loop = 0; loop < MAXTAGLOOP; loop++) {
111 const TValue *tm;
112 if (ttistable(t)) { /* `t' is a table? */
113 Table *h = hvalue(t);
114 const TValue *res = luaH_get(h, key); /* do a primitive get */
115 if (!ttisnil(res) || /* result is no nil? */
116 (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
117 setobj2s(L, val, res);
118 return;
119 }
120 /* else will try the tag method */
121 }
122 else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
123 luaG_typeerror(L, t, "index");
124 if (ttisfunction(tm)) {
125 callTMres(L, val, tm, t, key);
126 return;
127 }
128 t = tm; /* else repeat with `tm' */
129 }
130 luaG_runerror(L, "loop in gettable");
131}
132
133
134void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {
135 int loop;
136 TValue temp;
137 for (loop = 0; loop < MAXTAGLOOP; loop++) {
138 const TValue *tm;
139 if (ttistable(t)) { /* `t' is a table? */
140 Table *h = hvalue(t);
141 TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
142 if (!ttisnil(oldval) || /* result is no nil? */
143 (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */
144 setobj2t(L, oldval, val);
145 luaC_barriert(L, h, val);
146 return;
147 }
148 /* else will try the tag method */
149 }
150 else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
151 luaG_typeerror(L, t, "index");
152 if (ttisfunction(tm)) {
153 callTM(L, tm, t, key, val);
154 return;
155 }
156 /* else repeat with `tm' */
157 setobj(L, &temp, tm); /* avoid pointing inside table (may rehash) */
158 t = &temp;
159 }
160 luaG_runerror(L, "loop in settable");
161}
162
163
164static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
165 StkId res, TMS event) {
166 const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */
167 if (ttisnil(tm))
168 tm = luaT_gettmbyobj(L, p2, event); /* try second operand */
169 if (ttisnil(tm)) return 0;
170 callTMres(L, res, tm, p1, p2);
171 return 1;
172}
173
174
175static const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,
176 TMS event) {
177 const TValue *tm1 = fasttm(L, mt1, event);
178 const TValue *tm2;
179 if (tm1 == NULL) return NULL; /* no metamethod */
180 if (mt1 == mt2) return tm1; /* same metatables => same metamethods */
181 tm2 = fasttm(L, mt2, event);
182 if (tm2 == NULL) return NULL; /* no metamethod */
183 if (luaO_rawequalObj(tm1, tm2)) /* same metamethods? */
184 return tm1;
185 return NULL;
186}
187
188
189static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,
190 TMS event) {
191 const TValue *tm1 = luaT_gettmbyobj(L, p1, event);
192 const TValue *tm2;
193 if (ttisnil(tm1)) return -1; /* no metamethod? */
194 tm2 = luaT_gettmbyobj(L, p2, event);
195 if (!luaO_rawequalObj(tm1, tm2)) /* different metamethods? */
196 return -1;
197 callTMres(L, L->top, tm1, p1, p2);
198 return !l_isfalse(L->top);
199}
200
201
202static int l_strcmp (const TString *ls, const TString *rs) {
203 const char *l = getstr(ls);
204 size_t ll = ls->tsv.len;
205 const char *r = getstr(rs);
206 size_t lr = rs->tsv.len;
207 for (;;) {
208 int temp = strcoll(l, r);
209 if (temp != 0) return temp;
210 else { /* strings are equal up to a `\0' */
211 size_t len = strlen(l); /* index of first `\0' in both strings */
212 if (len == lr) /* r is finished? */
213 return (len == ll) ? 0 : 1;
214 else if (len == ll) /* l is finished? */
215 return -1; /* l is smaller than r (because r is not finished) */
216 /* both strings longer than `len'; go on comparing (after the `\0') */
217 len++;
218 l += len; ll -= len; r += len; lr -= len;
219 }
220 }
221}
222
223
224int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
225 int res;
226 if (ttype(l) != ttype(r))
227 return luaG_ordererror(L, l, r);
228 else if (ttisnumber(l))
229 return luai_numlt(nvalue(l), nvalue(r));
230 else if (ttisstring(l))
231 return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
232 else if ((res = call_orderTM(L, l, r, TM_LT)) != -1)
233 return res;
234 return luaG_ordererror(L, l, r);
235}
236
237
238int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) {
239 int res;
240 if (ttype(l) != ttype(r))
241 return luaG_ordererror(L, l, r);
242 else if (ttisnumber(l))
243 return luai_numle(nvalue(l), nvalue(r));
244 else if (ttisstring(l))
245 return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
246 else if ((res = call_orderTM(L, l, r, TM_LE)) != -1) /* first try `le' */
247 return res;
248 else if ((res = call_orderTM(L, r, l, TM_LT)) != -1) /* else try `lt' */
249 return !res;
250 return luaG_ordererror(L, l, r);
251}
252
253
254int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2) {
255 const TValue *tm;
256 lua_assert(ttype(t1) == ttype(t2));
257 switch (ttype(t1)) {
258 case LUA_TNIL: return 1;
259 case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));
260 case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */
261 case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
262 case LUA_TUSERDATA: {
263 if (uvalue(t1) == uvalue(t2)) return 1;
264 tm = get_compTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable,
265 TM_EQ);
266 break; /* will try TM */
267 }
268 case LUA_TTABLE: {
269 if (hvalue(t1) == hvalue(t2)) return 1;
270 tm = get_compTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
271 break; /* will try TM */
272 }
273 default: return gcvalue(t1) == gcvalue(t2);
274 }
275 if (tm == NULL) return 0; /* no TM? */
276 callTMres(L, L->top, tm, t1, t2); /* call TM */
277 return !l_isfalse(L->top);
278}
279
280
281void luaV_concat (lua_State *L, int total, int last) {
282 do {
283 StkId top = L->base + last + 1;
284 int n = 2; /* number of elements handled in this pass (at least 2) */
285 if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1)) {
286 if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT))
287 luaG_concaterror(L, top-2, top-1);
288 } else if (tsvalue(top-1)->len == 0) /* second op is empty? */
289 (void)tostring(L, top - 2); /* result is first op (as string) */
290 else {
291 /* at least two string values; get as many as possible */
292 size_t tl = tsvalue(top-1)->len;
293 char *buffer;
294 int i;
295 /* collect total length */
296 for (n = 1; n < total && tostring(L, top-n-1); n++) {
297 size_t l = tsvalue(top-n-1)->len;
298 if (l >= MAX_SIZET - tl) luaG_runerror(L, "string length overflow");
299 tl += l;
300 }
301 buffer = luaZ_openspace(L, &G(L)->buff, tl);
302 tl = 0;
303 for (i=n; i>0; i--) { /* concat all strings */
304 size_t l = tsvalue(top-i)->len;
305 memcpy(buffer+tl, svalue(top-i), l);
306 tl += l;
307 }
308 setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl));
309 }
310 total -= n-1; /* got `n' strings to create 1 new */
311 last -= n-1;
312 } while (total > 1); /* repeat until only 1 result left */
313}
314
315
316void luaV_arith (lua_State *L, StkId ra, const TValue *rb,
317 const TValue *rc, TMS op) {
318 TValue tempb, tempc;
319 const TValue *b, *c;
320 if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
321 (c = luaV_tonumber(rc, &tempc)) != NULL) {
322 lua_Number nb = nvalue(b), nc = nvalue(c);
323 switch (op) {
324 case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break;
325 case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break;
326 case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break;
327 case TM_DIV: setnvalue(ra, luai_numdiv(nb, nc)); break;
328 case TM_MOD: setnvalue(ra, luai_nummod(nb, nc)); break;
329 case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break;
330 case TM_UNM: setnvalue(ra, luai_numunm(nb)); break;
331 default: lua_assert(0); break;
332 }
333 }
334 else if (!call_binTM(L, rb, rc, ra, op))
335 luaG_aritherror(L, rb, rc);
336}
337
338
339
340/*
341** some macros for common tasks in `luaV_execute'
342*/
343
344#define runtime_check(L, c) { if (!(c)) break; }
345
346#define RA(i) (base+GETARG_A(i))
347/* to be used after possible stack reallocation */
348#define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
349#define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))
350#define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \
351 ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))
352#define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \
353 ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
354#define KBx(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, k+GETARG_Bx(i))
355
356
357#define dojump(L,pc,i) {(pc) += (i); luai_threadyield(L);}
358
359
360#define Protect(x) { L->savedpc = pc; {x;}; base = L->base; }
361
362
363#define arith_op(op,tm) { \
364 TValue *rb = RKB(i); \
365 TValue *rc = RKC(i); \
366 if (ttisnumber(rb) && ttisnumber(rc)) { \
367 lua_Number nb = nvalue(rb), nc = nvalue(rc); \
368 setnvalue(ra, op(nb, nc)); \
369 } \
370 else \
371 Protect(luaV_arith(L, ra, rb, rc, tm)); \
372 }
373
374
375
376void luaV_execute (lua_State *L, int nexeccalls) {
377 LClosure *cl;
378 StkId base;
379 TValue *k;
380 const Instruction *pc;
381 reentry: /* entry point */
382 lua_assert(isLua(L->ci));
383 pc = L->savedpc;
384 cl = &clvalue(L->ci->func)->l;
385 base = L->base;
386 k = cl->p->k;
387 /* main loop of interpreter */
388 for (;;) {
389 const Instruction i = *pc++;
390 StkId ra;
391 if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
392 (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
393 traceexec(L, pc);
394 if (L->status == LUA_YIELD) { /* did hook yield? */
395 L->savedpc = pc - 1;
396 return;
397 }
398 base = L->base;
399 }
400 /* warning!! several calls may realloc the stack and invalidate `ra' */
401 ra = RA(i);
402 lua_assert(base == L->base && L->base == L->ci->base);
403 lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
404 lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
405 switch (GET_OPCODE(i)) {
406 case OP_MOVE: {
407 setobjs2s(L, ra, RB(i));
408 continue;
409 }
410 case OP_LOADK: {
411 setobj2s(L, ra, KBx(i));
412 continue;
413 }
414 case OP_LOADBOOL: {
415 setbvalue(ra, GETARG_B(i));
416 if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
417 continue;
418 }
419 case OP_LOADNIL: {
420 TValue *rb = RB(i);
421 do {
422 setnilvalue(rb--);
423 } while (rb >= ra);
424 continue;
425 }
426 case OP_GETUPVAL: {
427 int b = GETARG_B(i);
428 setobj2s(L, ra, cl->upvals[b]->v);
429 continue;
430 }
431 case OP_GETGLOBAL: {
432 TValue g;
433 TValue *rb = KBx(i);
434 sethvalue(L, &g, cl->env);
435 lua_assert(ttisstring(rb));
436 Protect(luaV_gettable(L, &g, rb, ra));
437 continue;
438 }
439 case OP_GETTABLE: {
440 Protect(luaV_gettable(L, RB(i), RKC(i), ra));
441 continue;
442 }
443 case OP_SETGLOBAL: {
444 TValue g;
445 sethvalue(L, &g, cl->env);
446 lua_assert(ttisstring(KBx(i)));
447 Protect(luaV_settable(L, &g, KBx(i), ra));
448 continue;
449 }
450 case OP_SETUPVAL: {
451 UpVal *uv = cl->upvals[GETARG_B(i)];
452 setobj(L, uv->v, ra);
453 luaC_barrier(L, uv, ra);
454 continue;
455 }
456 case OP_SETTABLE: {
457 Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
458 continue;
459 }
460 case OP_NEWTABLE: {
461 int b = GETARG_B(i);
462 int c = GETARG_C(i);
463 sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
464 Protect(luaC_checkGC(L));
465 continue;
466 }
467 case OP_SELF: {
468 StkId rb = RB(i);
469 setobjs2s(L, ra+1, rb);
470 Protect(luaV_gettable(L, rb, RKC(i), ra));
471 continue;
472 }
473 case OP_ADD: {
474 arith_op(luai_numadd, TM_ADD);
475 continue;
476 }
477 case OP_SUB: {
478 arith_op(luai_numsub, TM_SUB);
479 continue;
480 }
481 case OP_MUL: {
482 arith_op(luai_nummul, TM_MUL);
483 continue;
484 }
485 case OP_DIV: {
486 arith_op(luai_numdiv, TM_DIV);
487 continue;
488 }
489 case OP_MOD: {
490 arith_op(luai_nummod, TM_MOD);
491 continue;
492 }
493 case OP_POW: {
494 arith_op(luai_numpow, TM_POW);
495 continue;
496 }
497 case OP_UNM: {
498 TValue *rb = RB(i);
499 if (ttisnumber(rb)) {
500 lua_Number nb = nvalue(rb);
501 setnvalue(ra, luai_numunm(nb));
502 }
503 else {
504 Protect(luaV_arith(L, ra, rb, rb, TM_UNM));
505 }
506 continue;
507 }
508 case OP_NOT: {
509 int res = l_isfalse(RB(i)); /* next assignment may change this value */
510 setbvalue(ra, res);
511 continue;
512 }
513 case OP_LEN: {
514 const TValue *rb = RB(i);
515 switch (ttype(rb)) {
516 case LUA_TTABLE: {
517 setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
518 break;
519 }
520 case LUA_TSTRING: {
521 setnvalue(ra, cast_num(tsvalue(rb)->len));
522 break;
523 }
524 default: { /* try metamethod */
525 Protect(
526 if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))
527 luaG_typeerror(L, rb, "get length of");
528 )
529 }
530 }
531 continue;
532 }
533 case OP_CONCAT: {
534 int b = GETARG_B(i);
535 int c = GETARG_C(i);
536 Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L));
537 setobjs2s(L, RA(i), base+b);
538 continue;
539 }
540 case OP_JMP: {
541 dojump(L, pc, GETARG_sBx(i));
542 continue;
543 }
544 case OP_EQ: {
545 TValue *rb = RKB(i);
546 TValue *rc = RKC(i);
547 Protect(
548 if (equalobj(L, rb, rc) == GETARG_A(i))
549 dojump(L, pc, GETARG_sBx(*pc));
550 )
551 pc++;
552 continue;
553 }
554 case OP_LT: {
555 Protect(
556 if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
557 dojump(L, pc, GETARG_sBx(*pc));
558 )
559 pc++;
560 continue;
561 }
562 case OP_LE: {
563 Protect(
564 if (luaV_lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
565 dojump(L, pc, GETARG_sBx(*pc));
566 )
567 pc++;
568 continue;
569 }
570 case OP_TEST: {
571 if (l_isfalse(ra) != GETARG_C(i))
572 dojump(L, pc, GETARG_sBx(*pc));
573 pc++;
574 continue;
575 }
576 case OP_TESTSET: {
577 TValue *rb = RB(i);
578 if (l_isfalse(rb) != GETARG_C(i)) {
579 setobjs2s(L, ra, rb);
580 dojump(L, pc, GETARG_sBx(*pc));
581 }
582 pc++;
583 continue;
584 }
585 case OP_CALL: {
586 int b = GETARG_B(i);
587 int nresults = GETARG_C(i) - 1;
588 if (b != 0) L->top = ra+b; /* else previous instruction set top */
589 L->savedpc = pc;
590 switch (luaD_precall(L, ra, nresults)) {
591 case PCRLUA: {
592 nexeccalls++;
593 goto reentry; /* restart luaV_execute over new Lua function */
594 }
595 case PCRC: {
596 /* it was a C function (`precall' called it); adjust results */
597 if (nresults >= 0) L->top = L->ci->top;
598 base = L->base;
599 continue;
600 }
601 default: {
602 return; /* yield */
603 }
604 }
605 }
606 case OP_TAILCALL: {
607 int b = GETARG_B(i);
608 if (b != 0) L->top = ra+b; /* else previous instruction set top */
609 L->savedpc = pc;
610 lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
611 switch (luaD_precall(L, ra, LUA_MULTRET)) {
612 case PCRLUA: {
613 /* tail call: put new frame in place of previous one */
614 CallInfo *ci = L->ci - 1; /* previous frame */
615 int aux;
616 StkId func = ci->func;
617 StkId pfunc = (ci+1)->func; /* previous function index */
618 if (L->openupval) luaF_close(L, ci->base);
619 L->base = ci->base = ci->func + ((ci+1)->base - pfunc);
620 for (aux = 0; pfunc+aux < L->top; aux++) /* move frame down */
621 setobjs2s(L, func+aux, pfunc+aux);
622 ci->top = L->top = func+aux; /* correct top */
623 lua_assert(L->top == L->base + clvalue(func)->l.p->maxstacksize);
624 ci->savedpc = L->savedpc;
625 ci->tailcalls++; /* one more call lost */
626 L->ci--; /* remove new frame */
627 goto reentry;
628 }
629 case PCRC: { /* it was a C function (`precall' called it) */
630 base = L->base;
631 continue;
632 }
633 default: {
634 return; /* yield */
635 }
636 }
637 }
638 case OP_RETURN: {
639 int b = GETARG_B(i);
640 if (b != 0) L->top = ra+b-1;
641 if (L->openupval) luaF_close(L, base);
642 L->savedpc = pc;
643 b = luaD_poscall(L, ra);
644 if (--nexeccalls == 0) /* was previous function running `here'? */
645 return; /* no: return */
646 else { /* yes: continue its execution */
647 if (b) L->top = L->ci->top;
648 lua_assert(isLua(L->ci));
649 lua_assert(GET_OPCODE(*((L->ci)->savedpc - 1)) == OP_CALL);
650 goto reentry;
651 }
652 }
653 case OP_FORLOOP: {
654 lua_Number step = nvalue(ra+2);
655 lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
656 lua_Number limit = nvalue(ra+1);
657 if (luai_numlt(0, step) ? luai_numle(idx, limit)
658 : luai_numle(limit, idx)) {
659 dojump(L, pc, GETARG_sBx(i)); /* jump back */
660 setnvalue(ra, idx); /* update internal index... */
661 setnvalue(ra+3, idx); /* ...and external index */
662 }
663 continue;
664 }
665 case OP_FORPREP: {
666 const TValue *init = ra;
667 const TValue *plimit = ra+1;
668 const TValue *pstep = ra+2;
669 L->savedpc = pc; /* next steps may throw errors */
670 if (!tonumber(init, ra))
671 luaG_runerror(L, LUA_QL("for") " initial value must be a number");
672 else if (!tonumber(plimit, ra+1))
673 luaG_runerror(L, LUA_QL("for") " limit must be a number");
674 else if (!tonumber(pstep, ra+2))
675 luaG_runerror(L, LUA_QL("for") " step must be a number");
676 setnvalue(ra, luai_numsub(nvalue(ra), nvalue(pstep)));
677 dojump(L, pc, GETARG_sBx(i));
678 continue;
679 }
680 case OP_TFORLOOP: {
681 StkId cb = ra + 3; /* call base */
682 setobjs2s(L, cb+2, ra+2);
683 setobjs2s(L, cb+1, ra+1);
684 setobjs2s(L, cb, ra);
685 L->top = cb+3; /* func. + 2 args (state and index) */
686 Protect(luaD_call(L, cb, GETARG_C(i)));
687 L->top = L->ci->top;
688 cb = RA(i) + 3; /* previous call may change the stack */
689 if (!ttisnil(cb)) { /* continue loop? */
690 setobjs2s(L, cb-1, cb); /* save control variable */
691 dojump(L, pc, GETARG_sBx(*pc)); /* jump back */
692 }
693 pc++;
694 continue;
695 }
696 case OP_SETLIST: {
697 int n = GETARG_B(i);
698 int c = GETARG_C(i);
699 int last;
700 Table *h;
701 if (n == 0) {
702 n = cast_int(L->top - ra) - 1;
703 L->top = L->ci->top;
704 }
705 if (c == 0) c = cast_int(*pc++);
706 runtime_check(L, ttistable(ra));
707 h = hvalue(ra);
708 last = ((c-1)*LFIELDS_PER_FLUSH) + n;
709 if (last > h->sizearray) /* needs more space? */
710 luaH_resizearray(L, h, last); /* pre-alloc it at once */
711 for (; n > 0; n--) {
712 TValue *val = ra+n;
713 setobj2t(L, luaH_setnum(L, h, last--), val);
714 luaC_barriert(L, h, val);
715 }
716 continue;
717 }
718 case OP_CLOSE: {
719 luaF_close(L, ra);
720 continue;
721 }
722 case OP_CLOSURE: {
723 Proto *p;
724 Closure *ncl;
725 int nup, j;
726 p = cl->p->p[GETARG_Bx(i)];
727 nup = p->nups;
728 ncl = luaF_newLclosure(L, nup, cl->env);
729 ncl->l.p = p;
730 for (j=0; j<nup; j++, pc++) {
731 if (GET_OPCODE(*pc) == OP_GETUPVAL)
732 ncl->l.upvals[j] = cl->upvals[GETARG_B(*pc)];
733 else {
734 lua_assert(GET_OPCODE(*pc) == OP_MOVE);
735 ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc));
736 }
737 }
738 setclvalue(L, ra, ncl);
739 Protect(luaC_checkGC(L));
740 continue;
741 }
742 case OP_VARARG: {
743 int b = GETARG_B(i) - 1;
744 int j;
745 CallInfo *ci = L->ci;
746 int n = cast_int(ci->base - ci->func) - cl->p->numparams - 1;
747 if (b == LUA_MULTRET) {
748 Protect(luaD_checkstack(L, n));
749 ra = RA(i); /* previous call may change the stack */
750 b = n;
751 L->top = ra + n;
752 }
753 for (j = 0; j < b; j++) {
754 if (j < n) {
755 setobjs2s(L, ra + j, ci->base - n + j);
756 }
757 else {
758 setnilvalue(ra + j);
759 }
760 }
761 continue;
762 }
763 }
764 }
765}
766
diff --git a/libraries/LuaJIT-1.1.7/src/lvm.h b/libraries/LuaJIT-1.1.7/src/lvm.h
new file mode 100644
index 0000000..506a294
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lvm.h
@@ -0,0 +1,40 @@
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
25LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
26LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r);
27LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
28LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
29LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
30LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key,
31 StkId val);
32LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key,
33 StkId val);
34LUAI_FUNC void luaV_arith (lua_State *L, StkId ra, const TValue *rb,
35 const TValue *rc, TMS op);
36
37LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);
38LUAI_FUNC void luaV_concat (lua_State *L, int total, int last);
39
40#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lzio.c b/libraries/LuaJIT-1.1.7/src/lzio.c
new file mode 100644
index 0000000..293edd5
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lzio.c
@@ -0,0 +1,82 @@
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
21int 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
35int 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
48void 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 --- */
58size_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/* ------------------------------------------------------------------------ */
74char *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
diff --git a/libraries/LuaJIT-1.1.7/src/lzio.h b/libraries/LuaJIT-1.1.7/src/lzio.h
new file mode 100644
index 0000000..51d695d
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lzio.h
@@ -0,0 +1,67 @@
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
18typedef 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
24typedef 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
46LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n);
47LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
48 void *data);
49LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n); /* read next n bytes */
50LUAI_FUNC int luaZ_lookahead (ZIO *z);
51
52
53
54/* --------- Private Part ------------------ */
55
56struct 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
65LUAI_FUNC int luaZ_fill (ZIO *z);
66
67#endif
diff --git a/libraries/LuaJIT-1.1.7/src/print.c b/libraries/LuaJIT-1.1.7/src/print.c
new file mode 100644
index 0000000..e240cfc
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/print.c
@@ -0,0 +1,227 @@
1/*
2** $Id: print.c,v 1.55a 2006/05/31 13:30:05 lhf Exp $
3** print bytecodes
4** See Copyright Notice in lua.h
5*/
6
7#include <ctype.h>
8#include <stdio.h>
9
10#define luac_c
11#define LUA_CORE
12
13#include "ldebug.h"
14#include "lobject.h"
15#include "lopcodes.h"
16#include "lundump.h"
17
18#define PrintFunction luaU_print
19
20#define Sizeof(x) ((int)sizeof(x))
21#define VOID(p) ((const void*)(p))
22
23static void PrintString(const TString* ts)
24{
25 const char* s=getstr(ts);
26 size_t i,n=ts->tsv.len;
27 putchar('"');
28 for (i=0; i<n; i++)
29 {
30 int c=s[i];
31 switch (c)
32 {
33 case '"': printf("\\\""); break;
34 case '\\': printf("\\\\"); break;
35 case '\a': printf("\\a"); break;
36 case '\b': printf("\\b"); break;
37 case '\f': printf("\\f"); break;
38 case '\n': printf("\\n"); break;
39 case '\r': printf("\\r"); break;
40 case '\t': printf("\\t"); break;
41 case '\v': printf("\\v"); break;
42 default: if (isprint((unsigned char)c))
43 putchar(c);
44 else
45 printf("\\%03u",(unsigned char)c);
46 }
47 }
48 putchar('"');
49}
50
51static void PrintConstant(const Proto* f, int i)
52{
53 const TValue* o=&f->k[i];
54 switch (ttype(o))
55 {
56 case LUA_TNIL:
57 printf("nil");
58 break;
59 case LUA_TBOOLEAN:
60 printf(bvalue(o) ? "true" : "false");
61 break;
62 case LUA_TNUMBER:
63 printf(LUA_NUMBER_FMT,nvalue(o));
64 break;
65 case LUA_TSTRING:
66 PrintString(rawtsvalue(o));
67 break;
68 default: /* cannot happen */
69 printf("? type=%d",ttype(o));
70 break;
71 }
72}
73
74static void PrintCode(const Proto* f)
75{
76 const Instruction* code=f->code;
77 int pc,n=f->sizecode;
78 for (pc=0; pc<n; pc++)
79 {
80 Instruction i=code[pc];
81 OpCode o=GET_OPCODE(i);
82 int a=GETARG_A(i);
83 int b=GETARG_B(i);
84 int c=GETARG_C(i);
85 int bx=GETARG_Bx(i);
86 int sbx=GETARG_sBx(i);
87 int line=getline(f,pc);
88 printf("\t%d\t",pc+1);
89 if (line>0) printf("[%d]\t",line); else printf("[-]\t");
90 printf("%-9s\t",luaP_opnames[o]);
91 switch (getOpMode(o))
92 {
93 case iABC:
94 printf("%d",a);
95 if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (-1-INDEXK(b)) : b);
96 if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (-1-INDEXK(c)) : c);
97 break;
98 case iABx:
99 if (getBMode(o)==OpArgK) printf("%d %d",a,-1-bx); else printf("%d %d",a,bx);
100 break;
101 case iAsBx:
102 if (o==OP_JMP) printf("%d",sbx); else printf("%d %d",a,sbx);
103 break;
104 }
105 switch (o)
106 {
107 case OP_LOADK:
108 printf("\t; "); PrintConstant(f,bx);
109 break;
110 case OP_GETUPVAL:
111 case OP_SETUPVAL:
112 printf("\t; %s", (f->sizeupvalues>0) ? getstr(f->upvalues[b]) : "-");
113 break;
114 case OP_GETGLOBAL:
115 case OP_SETGLOBAL:
116 printf("\t; %s",svalue(&f->k[bx]));
117 break;
118 case OP_GETTABLE:
119 case OP_SELF:
120 if (ISK(c)) { printf("\t; "); PrintConstant(f,INDEXK(c)); }
121 break;
122 case OP_SETTABLE:
123 case OP_ADD:
124 case OP_SUB:
125 case OP_MUL:
126 case OP_DIV:
127 case OP_POW:
128 case OP_EQ:
129 case OP_LT:
130 case OP_LE:
131 if (ISK(b) || ISK(c))
132 {
133 printf("\t; ");
134 if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf("-");
135 printf(" ");
136 if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf("-");
137 }
138 break;
139 case OP_JMP:
140 case OP_FORLOOP:
141 case OP_FORPREP:
142 printf("\t; to %d",sbx+pc+2);
143 break;
144 case OP_CLOSURE:
145 printf("\t; %p",VOID(f->p[bx]));
146 break;
147 case OP_SETLIST:
148 if (c==0) printf("\t; %d",(int)code[++pc]);
149 else printf("\t; %d",c);
150 break;
151 default:
152 break;
153 }
154 printf("\n");
155 }
156}
157
158#define SS(x) (x==1)?"":"s"
159#define S(x) x,SS(x)
160
161static void PrintHeader(const Proto* f)
162{
163 const char* s=getstr(f->source);
164 if (*s=='@' || *s=='=')
165 s++;
166 else if (*s==LUA_SIGNATURE[0])
167 s="(bstring)";
168 else
169 s="(string)";
170 printf("\n%s <%s:%d,%d> (%d instruction%s, %d bytes at %p)\n",
171 (f->linedefined==0)?"main":"function",s,
172 f->linedefined,f->lastlinedefined,
173 S(f->sizecode),f->sizecode*Sizeof(Instruction),VOID(f));
174 printf("%d%s param%s, %d slot%s, %d upvalue%s, ",
175 f->numparams,f->is_vararg?"+":"",SS(f->numparams),
176 S(f->maxstacksize),S(f->nups));
177 printf("%d local%s, %d constant%s, %d function%s\n",
178 S(f->sizelocvars),S(f->sizek),S(f->sizep));
179}
180
181static void PrintConstants(const Proto* f)
182{
183 int i,n=f->sizek;
184 printf("constants (%d) for %p:\n",n,VOID(f));
185 for (i=0; i<n; i++)
186 {
187 printf("\t%d\t",i+1);
188 PrintConstant(f,i);
189 printf("\n");
190 }
191}
192
193static void PrintLocals(const Proto* f)
194{
195 int i,n=f->sizelocvars;
196 printf("locals (%d) for %p:\n",n,VOID(f));
197 for (i=0; i<n; i++)
198 {
199 printf("\t%d\t%s\t%d\t%d\n",
200 i,getstr(f->locvars[i].varname),f->locvars[i].startpc+1,f->locvars[i].endpc+1);
201 }
202}
203
204static void PrintUpvalues(const Proto* f)
205{
206 int i,n=f->sizeupvalues;
207 printf("upvalues (%d) for %p:\n",n,VOID(f));
208 if (f->upvalues==NULL) return;
209 for (i=0; i<n; i++)
210 {
211 printf("\t%d\t%s\n",i,getstr(f->upvalues[i]));
212 }
213}
214
215void PrintFunction(const Proto* f, int full)
216{
217 int i,n=f->sizep;
218 PrintHeader(f);
219 PrintCode(f);
220 if (full)
221 {
222 PrintConstants(f);
223 PrintLocals(f);
224 PrintUpvalues(f);
225 }
226 for (i=0; i<n; i++) PrintFunction(f->p[i],full);
227}
generated by cgit v1.1 at 2024-11-09 12:04:35 +0000